@azure-net/cli 2.0.9 → 2.1.1

package/bin/azure-net.js

@@ -8,7 +8,8 @@ import {
     initEdges,
     initTranslations,
     initSchema,
-    initLint
+    initLint,
+    initPresenter
 } from '../src/commands/init/index.js';
 import {
     generateDatasource,
@@ -67,6 +68,11 @@ program
     .description('Initialize schema factory')
     .action(initSchema);
 
+program
+    .command('init:presenter')
+    .description('Initialize presenter factory')
+    .action(initPresenter);
+
 program
     .command('init')
     .description('Run all initialization steps')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-net/cli",
-  "version": "2.0.9",
+  "version": "2.1.1",
   "type": "module",
   "bin": {
     "azure-net": "bin/azure-net.js"

package/src/commands/generate/generateCrudBase.js

@@ -1,7 +1,7 @@
 import prompts from 'prompts';
 import path from 'path';
 import { selectContext, getContextPath, toPascalCase, toCamelCase, getAvailableFiles } from '../../utils/contextUtils.js';
-import { writeIfNotExists, updateIndexTs } from '../../utils/fileUtils.js';
+import { writeIfNotExists, updateIndexTs, updateCoreIndex } from '../../utils/fileUtils.js';
 
 // Templates for CRUD base generation
 const entityTemplate = `export interface I{{name}} {
@@ -11,7 +11,7 @@ const entityTemplate = `export interface I{{name}} {
 \tupdated_at: string;
 }`;
 
-const portsIndexTemplate = `import type { I{{name}} } from '\${{context}}/Domain/Entities/{{name}}';
+const portsIndexTemplate = `import type { I{{name}} } from '\${{context}}/Domain/{{name}}/Model';
 
 export interface I{{name}}Collection {
 \tdata: I{{name}}[];
@@ -35,13 +35,13 @@ export interface I{{name}}UpdateRequest {
 }`;
 
 const repositoryTemplate = `import { {{datasource}} } from '{{datasourceImport}}';
-import type { I{{name}} } from '\${{context}}/Domain/Entities/{{name}}';
+import type { I{{name}} } from '\${{context}}/Domain/{{name}}/Model';
 import type { 
 \tI{{name}}Collection,
 \tI{{name}}CollectionQuery,
 \tI{{name}}CreateRequest,
 \tI{{name}}UpdateRequest
-} from '\${{context}}/Domain/Ports/{{name}}';
+} from '\${{context}}/Domain/{{name}}/Ports';
 
 export class {{name}}Repository {
 \tprivate endpoint = '{{endpoint}}';
@@ -111,15 +111,15 @@ export default async function generateCrudBase() {
 
     // Get available datasources
     const contextPath = getContextPath(context);
-    const sharedDatasources = await getAvailableFiles(
-        path.join(process.cwd(), 'src/app/shared/Datasource')
+    const coreDatasources = await getAvailableFiles(
+        path.join(process.cwd(), 'src/app/core/Datasource')
     );
     const contextDatasources = await getAvailableFiles(
         path.join(contextPath, 'Infrastructure/Http/Datasource')
     );
 
     const allDatasources = [
-        ...sharedDatasources.map(d => ({ title: `${d} (shared)`, value: { name: d, from: 'shared' } })),
+        ...coreDatasources.map(d => ({ title: `${d} (core)`, value: { name: d, from: 'core' } })),
         ...contextDatasources.map(d => ({ title: `${d} (${context})`, value: { name: d, from: context } }))
     ];
 
@@ -135,15 +135,18 @@ export default async function generateCrudBase() {
 
     console.log('\n🚀 Generating CRUD base (repository & service)...\n');
 
-    // 1. Create Entity
-    const entityPath = path.join(contextPath, 'Domain/Entities', pascalName);
+    // 1. Create Domain structure
+    const domainPath = path.join(contextPath, 'Domain', pascalName);
+    const modelPath = path.join(domainPath, 'Model');
+    const portsPath = path.join(domainPath, 'Ports');
+
+    // Create Model
     await writeIfNotExists(
-        path.join(entityPath, 'index.ts'),
+        path.join(modelPath, 'index.ts'),
         entityTemplate.replace(/{{name}}/g, pascalName)
     );
 
-    // 2. Create Ports
-    const portsPath = path.join(contextPath, 'Domain/Ports', pascalName);
+    // Create Ports
     await writeIfNotExists(
         path.join(portsPath, 'index.ts'),
         portsIndexTemplate
@@ -151,10 +154,16 @@ export default async function generateCrudBase() {
             .replace(/{{context}}/g, context)
     );
 
-    // 3. Create Repository
+    // Create Domain module index
+    await writeIfNotExists(
+        path.join(domainPath, 'index.ts'),
+        `export * from './Model';\nexport * from './Ports';`
+    );
+
+    // 2. Create Repository
     const repoPath = path.join(contextPath, 'Infrastructure/Http/Repositories');
-    const datasourceImport = datasource.from === 'shared'
-        ? '$shared/Datasource'
+    const datasourceImport = datasource.from === 'core'
+        ? '$core/Datasource'
         : `\$${context}/Infrastructure/Http/Datasource`;
 
     await writeIfNotExists(
@@ -169,7 +178,7 @@ export default async function generateCrudBase() {
     );
     await updateIndexTs(repoPath);
 
-    // 4. Create Service
+    // 3. Create Service
     const servicePath = path.join(contextPath, 'Application/Services');
     await writeIfNotExists(
         path.join(servicePath, `${pascalName}Service.ts`),
@@ -180,6 +189,9 @@ export default async function generateCrudBase() {
     );
     await updateIndexTs(servicePath);
 
+    // Update core index
+    await updateCoreIndex();
+
     console.log(`✅ CRUD base for ${pascalName} created successfully!`);
     console.log(`\n💡 Remember to:`);
     console.log(`   1. Add ${pascalName}Repository to InfrastructureProvider`);

package/src/commands/generate/generateCrudPresenter.js

@@ -1,11 +1,10 @@
 import prompts from 'prompts';
 import path from 'path';
-import fs from 'fs/promises';
 import { selectContext, getContextPath, toPascalCase, getAvailableFiles, getApplicationProviderServices } from '../../utils/contextUtils.js';
-import {updateIndexTs, writeIfNotExists} from '../../utils/fileUtils.js';
+import { updateIndexTs, writeIfNotExists, updateCoreIndex } from '../../utils/fileUtils.js';
 
 const createSchemaTemplate = `import { {{schemaFactory}} } from '{{schemaImport}}';
-import type { I{{name}}CreateRequest } from '\${{context}}/Domain/Ports/{{entity}}';
+import type { I{{name}}CreateRequest } from '\${{context}}/Domain/{{entity}}/Ports';
 
 export const Create{{name}}Schema = {{schemaFactory}}<I{{name}}CreateRequest>()
 \t.rules((rules) => ({
@@ -14,7 +13,7 @@ export const Create{{name}}Schema = {{schemaFactory}}<I{{name}}CreateRequest>()
 \t.create();`;
 
 const updateSchemaTemplate = `import { {{schemaFactory}} } from '{{schemaImport}}';
-import type { I{{name}}UpdateRequest } from '\${{context}}/Domain/Ports/{{entity}}';
+import type { I{{name}}UpdateRequest } from '\${{context}}/Domain/{{entity}}/Ports';
 
 export const Update{{name}}Schema = {{schemaFactory}}<I{{name}}UpdateRequest>()
 \t.rules((rules) => ({
@@ -22,14 +21,14 @@ export const Update{{name}}Schema = {{schemaFactory}}<I{{name}}UpdateRequest>()
 \t}))
 \t.create();`;
 
-const presenterWithSharedTemplate = `import { {{presenterFactory}} } from '$shared/Presenter';
+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}}';
+} from '\${{context}}/Domain/{{name}}/Ports';
 
 export const {{name}}Presenter = {{presenterFactory}}('{{name}}Presenter', ({ createAsyncResource, createAsyncAction }) => {
 \tconst { {{serviceName}} } = ApplicationProvider();
@@ -52,14 +51,14 @@ export const {{name}}Presenter = {{presenterFactory}}('{{name}}Presenter', ({ cr
 \treturn { collection, resource, create, update, remove };
 });`;
 
-const presenterWithoutSharedTemplate = `import { createPresenter } from '@azure-net/kit';
+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}}';
+} from '\${{context}}/Domain/{{name}}/Ports';
 
 export const {{name}}Presenter = createPresenter('{{name}}Presenter', () => {
 \tconst { {{serviceName}} } = ApplicationProvider();
@@ -74,7 +73,7 @@ export const {{name}}Presenter = createPresenter('{{name}}Presenter', () => {
 \t\tawait {{serviceName}}.create(Create{{name}}Schema.from(request).json());
 \t
 \tconst update = async (id: number, request: I{{name}}UpdateRequest) =>
-\t\tawait {{serviceName}}.update(id, Update{{name}}Schema.from(request).json());
+\t\tawait {{serviceName}}.update(id, Update{{name}}Schema.from(request).json()));
 \t
 \tconst remove = async (id: number) => 
 \t\tawait {{serviceName}}.remove(id);
@@ -105,8 +104,8 @@ export default async function generateCrudPresenter() {
     const pascalName = toPascalCase(entityName);
 
     // Get schema factory
-    const sharedSchemas = await getAvailableFiles(
-        path.join(process.cwd(), 'src/app/shared/Schema')
+    const coreSchemas = await getAvailableFiles(
+        path.join(process.cwd(), 'src/app/core/Schema')
     );
 
     const { schemaType } = await prompts({
@@ -115,13 +114,13 @@ export default async function generateCrudPresenter() {
         message: 'Select schema factory:',
         choices: [
             { title: 'Use createSchemaFactory from package', value: 'package' },
-            ...sharedSchemas.map(s => ({ title: `Use ${s} from shared`, value: s }))
+            ...coreSchemas.map(s => ({ title: `Use ${s} from core`, value: s }))
         ]
     });
 
     // Get presenter factory
-    const sharedPresenters = await getAvailableFiles(
-        path.join(process.cwd(), 'src/app/shared/Presenter')
+    const corePresenters = await getAvailableFiles(
+        path.join(process.cwd(), 'src/app/core/Presenter')
     );
 
     const { presenterType } = await prompts({
@@ -130,7 +129,7 @@ export default async function generateCrudPresenter() {
         message: 'Select presenter factory:',
         choices: [
             { title: 'Use createPresenter from package', value: 'package' },
-            ...sharedPresenters.map(p => ({ title: `Use ${p} from shared`, value: p }))
+            ...corePresenters.map(p => ({ title: `Use ${p} from core`, value: p }))
         ]
     });
 
@@ -144,7 +143,7 @@ export default async function generateCrudPresenter() {
     const schemaFactory = schemaType === 'package' ? 'Schema' : schemaType;
     const schemaImport = schemaType === 'package'
         ? '@azure-net/kit'
-        : '$shared/Schema';
+        : '$core/Schema';
 
     if (schemaType === 'package') {
         const schemaImportFull = `import { createSchemaFactory } from '@azure-net/kit';
@@ -196,8 +195,8 @@ const Schema = createSchemaFactory(createRules(validationMessagesI18n));`;
 
     // Create Presenter
     const presenterTemplate = presenterType === 'package'
-        ? presenterWithoutSharedTemplate
-        : presenterWithSharedTemplate;
+        ? presenterWithoutCoreTemplate
+        : presenterWithCoreTemplate;
 
     const presenterFactory = presenterType === 'package' ? 'createPresenter' : presenterType;
 
@@ -216,5 +215,8 @@ const Schema = createSchemaFactory(createRules(validationMessagesI18n));`;
         `export * from './${pascalName}Presenter';\nexport * from './Schema';`
     );
 
+    // Update core index
+    await updateCoreIndex();
+
     console.log(`✅ CRUD presenter for ${pascalName} created successfully!`);
 }

package/src/commands/generate/generateDatasource.js

@@ -1,19 +1,19 @@
 import prompts from 'prompts';
 import path from 'path';
 import { selectContext, getContextPath, toPascalCase, getAvailableFiles } from '../../utils/contextUtils.js';
-import { writeIfNotExists, updateIndexTs } from '../../utils/fileUtils.js';
+import { writeIfNotExists, updateIndexTs, updateCoreIndex } from '../../utils/fileUtils.js';
 
 const datasourceWithResponseTemplate = `import { BaseHttpDatasource, type CreateRequestCallbackType } from '@azure-net/kit/infra';
-import { {{responseClass}}, type {{responseInterface}} } from '{{responseImport}}';
+import { {{responseClass}} } from '{{responseImport}}';
 
 export class {{name}}Datasource extends BaseHttpDatasource {
-\tasync createRequest<T>(callback: CreateRequestCallbackType<{{responseInterface}}<T>>) {
-\t\treturn new {{responseClass}}<T>(await this.createRawRequest<{{responseInterface}}<T>>(callback));
+\tasync createRequest<T>(callback: CreateRequestCallbackType<T>) {
+\t\treturn new {{responseClass}}<T>(await this.createRawRequest<T>(callback));
 \t}
 }`;
 
 export default async function generateDatasource() {
-    const context = await selectContext('Select context for datasource (or shared):');
+    const context = await selectContext('Select context for datasource (or core):');
 
     const { name } = await prompts({
         type: 'text',
@@ -22,23 +22,23 @@ export default async function generateDatasource() {
     });
 
     const pascalName = toPascalCase(name);
-    const contextPath = context === 'shared'
-        ? path.join(process.cwd(), 'src/app/shared')
+    const contextPath = context === 'core'
+        ? path.join(process.cwd(), 'src/app/core')
         : getContextPath(context);
 
     // Get available responses
-    const sharedResponses = await getAvailableFiles(
-        path.join(process.cwd(), 'src/app/shared/Response')
+    const coreResponses = await getAvailableFiles(
+        path.join(process.cwd(), 'src/app/core/Response')
     );
 
-    const contextResponses = context !== 'shared'
+    const contextResponses = context !== 'core'
         ? await getAvailableFiles(path.join(contextPath, 'Infrastructure/Response'))
         : [];
 
     const allResponses = [
-        ...sharedResponses.map(r => ({
-            title: `${r} (shared)`,
-            value: { name: r, from: 'shared' }
+        ...coreResponses.map(r => ({
+            title: `${r} (core)`,
+            value: { name: r, from: 'core' }
         })),
         ...contextResponses.map(r => ({
             title: `${r} (${context})`,
@@ -58,26 +58,27 @@ export default async function generateDatasource() {
         choices: allResponses
     });
 
-    // Determine interface name
-    const responseInterface = `I${response.name.replace('Response', '')}Response`;
-
-    const datasourcePath = context === 'shared'
+    const datasourcePath = context === 'core'
         ? path.join(contextPath, 'Datasource')
         : path.join(contextPath, 'Infrastructure/Http/Datasource');
 
-    const responseImport = response.from === 'shared'
-        ? context === 'shared' ? '../Response' : '$shared/Response'
+    const responseImport = response.from === 'core'
+        ? context === 'core' ? '../Response' : '$core/Response'
         : `\$${context}/Infrastructure/Response`;
 
     const content = datasourceWithResponseTemplate
         .replace(/{{name}}/g, pascalName)
         .replace(/{{responseClass}}/g, response.name)
-        .replace(/{{responseInterface}}/g, responseInterface)
         .replace(/{{responseImport}}/g, responseImport);
 
     const filePath = path.join(datasourcePath, `${pascalName}Datasource.ts`);
     await writeIfNotExists(filePath, content);
     await updateIndexTs(datasourcePath);
 
+    // Update core index if needed
+    if (context === 'core') {
+        await updateCoreIndex();
+    }
+
     console.log(`✅ Datasource created at ${filePath}`);
 }

package/src/commands/generate/generatePresenter.js

@@ -1,17 +1,16 @@
 import prompts from 'prompts';
 import path from 'path';
-import fs from 'fs/promises';
 import { selectContext, getContextPath, toPascalCase, getAvailableFiles } from '../../utils/contextUtils.js';
-import { writeIfNotExists } from '../../utils/fileUtils.js';
+import { writeIfNotExists, updateCoreIndex } from '../../utils/fileUtils.js';
 
-const presenterWithSharedTemplate = `import { {{sharedPresenter}} } from '$shared/Presenter';
+const presenterWithCoreTemplate = `import { {{corePresenter}} } from '$core/Presenter';
 import { ApplicationProvider } from '\${{context}}/Application';
 
-export const {{name}}Presenter = {{sharedPresenter}}('{{name}}Presenter', ({ createAsyncResource, createAsyncAction }) => {
+export const {{name}}Presenter = {{corePresenter}}('{{name}}Presenter', ({ createAsyncResource, createAsyncAction }) => {
 \tconst { /* extract services from ApplicationProvider */ } = ApplicationProvider();
 \t
 \tconst example = async () => {
-\t\t// Using async helpers from shared presenter factory
+\t\t// Using async helpers from core presenter factory
 \t\treturn await createAsyncResource(Promise.resolve({}));
 \t};
 \t
@@ -41,14 +40,14 @@ export default async function generatePresenter() {
         message: 'Module name (will create folder in Delivery):'
     });
 
-    // Check for shared presenters
-    const sharedPresenters = await getAvailableFiles(
-        path.join(process.cwd(), 'src/app/shared/Presenter')
+    // Check for core presenters
+    const corePresenters = await getAvailableFiles(
+        path.join(process.cwd(), 'src/app/core/Presenter')
     );
 
     const presenterChoices = [
         { title: 'Use createPresenter from package', value: 'package' },
-        ...sharedPresenters.map(p => ({ title: `Use ${p} from shared`, value: p }))
+        ...corePresenters.map(p => ({ title: `Use ${p} from core`, value: p }))
     ];
 
     const { presenterType } = await prompts({
@@ -67,9 +66,9 @@ export default async function generatePresenter() {
         ? presenterWithPackageTemplate
             .replace(/{{name}}/g, pascalName)
             .replace(/{{context}}/g, context)
-        : presenterWithSharedTemplate
+        : presenterWithCoreTemplate
             .replace(/{{name}}/g, pascalName)
-            .replace(/{{sharedPresenter}}/g, presenterType)
+            .replace(/{{corePresenter}}/g, presenterType)
             .replace(/{{context}}/g, context);
 
     await writeIfNotExists(filePath, content);
@@ -78,6 +77,9 @@ export default async function generatePresenter() {
         `export * from './${pascalName}Presenter';`
     );
 
+    // Update core index
+    await updateCoreIndex();
+
     console.log(`✅ Presenter created at ${filePath}`);
     console.log(`\n💡 Remember to extract needed services from ApplicationProvider in the presenter.`);
 }

package/src/commands/generate/generateRepository.js

@@ -1,7 +1,7 @@
 import prompts from 'prompts';
 import path from 'path';
 import { selectContext, getContextPath, toPascalCase, getAvailableFiles, toCamelCase } from '../../utils/contextUtils.js';
-import { writeIfNotExists, updateIndexTs } from '../../utils/fileUtils.js';
+import { writeIfNotExists, updateIndexTs, updateCoreIndex } from '../../utils/fileUtils.js';
 
 const repositoryTemplate = `import { {{datasource}} } from '{{datasourceImport}}';
 
@@ -26,15 +26,15 @@ export default async function generateRepository() {
 
     // Get available datasources
     const contextPath = getContextPath(context);
-    const sharedDatasources = await getAvailableFiles(
-        path.join(process.cwd(), 'src/app/shared/Datasource')
+    const coreDatasources = await getAvailableFiles(
+        path.join(process.cwd(), 'src/app/core/Datasource')
     );
     const contextDatasources = await getAvailableFiles(
         path.join(contextPath, 'Infrastructure/Http/Datasource')
     );
 
     const allDatasources = [
-        ...sharedDatasources.map(d => ({ title: `${d} (shared)`, value: { name: d, from: 'shared' } })),
+        ...coreDatasources.map(d => ({ title: `${d} (core)`, value: { name: d, from: 'core' } })),
         ...contextDatasources.map(d => ({ title: `${d} (${context})`, value: { name: d, from: context } }))
     ];
 
@@ -55,8 +55,8 @@ export default async function generateRepository() {
     const filePath = path.join(repoPath, `${pascalName}Repository.ts`);
 
     // Generate repository
-    const datasourceImport = datasource.from === 'shared'
-        ? '$shared/Datasource'
+    const datasourceImport = datasource.from === 'core'
+        ? '$core/Datasource'
         : `\$${context}/Infrastructure/Http/Datasource`;
 
     const content = repositoryTemplate
@@ -68,6 +68,9 @@ export default async function generateRepository() {
     await writeIfNotExists(filePath, content);
     await updateIndexTs(repoPath);
 
+    // Update core index
+    await updateCoreIndex();
+
     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

@@ -1,7 +1,7 @@
 import prompts from 'prompts';
 import path from 'path';
 import { selectContext, getContextPath, toPascalCase } from '../../utils/contextUtils.js';
-import { writeIfNotExists, updateIndexTs } from '../../utils/fileUtils.js';
+import { writeIfNotExists, updateIndexTs, updateCoreIndex } from '../../utils/fileUtils.js';
 
 const responseTemplate = `import { ResponseBuilder } from '@azure-net/kit/infra';
 
@@ -9,7 +9,7 @@ export class {{name}}Response<TData = unknown, TMeta = unknown> extends Response
 }`;
 
 export default async function generateResponse() {
-    const context = await selectContext('Select context for response (or shared):');
+    const context = await selectContext('Select context for response (or core):');
 
     const { name } = await prompts({
         type: 'text',
@@ -18,11 +18,11 @@ export default async function generateResponse() {
     });
 
     const pascalName = toPascalCase(name);
-    const contextPath = context === 'shared'
-        ? path.join(process.cwd(), 'src/app/shared')
+    const contextPath = context === 'core'
+        ? path.join(process.cwd(), 'src/app/core')
         : getContextPath(context);
 
-    const responsePath = context === 'shared'
+    const responsePath = context === 'core'
         ? path.join(contextPath, 'Response')
         : path.join(contextPath, 'Infrastructure/Response');
 
@@ -32,5 +32,10 @@ export default async function generateResponse() {
     await writeIfNotExists(filePath, content);
     await updateIndexTs(responsePath);
 
+    // Update core index if needed
+    if (context === 'core') {
+        await updateCoreIndex();
+    }
+
     console.log(`✅ Response created at ${filePath}`);
 }

package/src/commands/init/index.js

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

package/src/commands/init/initAliases.js

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

package/src/commands/init/initMiddleware.js

@@ -1,7 +1,7 @@
-import { writeIfNotExists, injectIntoFile } from '../../utils/fileUtils.js';
+import { writeIfNotExists, updateCoreIndex } from '../../utils/fileUtils.js';
 import path from 'path';
 
-const middlewarePath = path.join(process.cwd(), 'src/app/shared/Middleware/MiddlewareManager.ts');
+const middlewarePath = path.join(process.cwd(), 'src/app/core/Middleware/MiddlewareManager.ts');
 
 const middlewareTemplate = `import { createMiddlewareManager } from '@azure-net/kit';
 
@@ -10,9 +10,12 @@ export const { clientMiddleware, serverMiddleware } = createMiddlewareManager([]
 export default async function initMiddleware() {
     await writeIfNotExists(middlewarePath, middlewareTemplate);
     await writeIfNotExists(
-        path.join(process.cwd(), 'src/app/shared/Middleware/index.ts'),
+        path.join(process.cwd(), 'src/app/core/Middleware/index.ts'),
         `export * from './MiddlewareManager';`
     );
 
+    // Update core index
+    await updateCoreIndex();
+
     console.log('✅ Middleware initialized');
 }

package/src/commands/init/initPresenter.js

@@ -0,0 +1,22 @@
+import { writeIfNotExists } from '../../utils/fileUtils.js';
+import path from 'path';
+
+const presenterPath = path.join(process.cwd(), 'src/app/core/Presenter/AppPresenter.ts');
+
+const presenterTemplate = `import { createPresenterFactory } from '@azure-net/kit/edges';
+import { createAsyncHelpers, createErrorParser } from '@azure-net/kit';
+
+const ErrorHandler = createErrorParser();
+const AsyncHelpers = createAsyncHelpers({ parseError: ErrorHandler });
+
+export const AppPresenter = createPresenterFactory({ ...AsyncHelpers, handleError: ErrorHandler });`;
+
+export default async function initPresenter() {
+    await writeIfNotExists(presenterPath, presenterTemplate);
+    await writeIfNotExists(
+        path.join(process.cwd(), 'src/app/core/Presenter/index.ts'),
+        `export * from './AppPresenter';`
+    );
+
+    console.log('✅ Presenter factory initialized');
+}

package/src/commands/init/initSchema.js

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

package/src/commands/init/initStructure.js

@@ -1,11 +1,12 @@
 import fs from 'fs/promises';
 import path from 'path';
 import { loadUserConfig } from '../../utils/loadConfig.js';
+import { updateCoreIndex } from '../../utils/fileUtils.js';
 
 const APP_ROOT = path.join(process.cwd(), 'src', 'app');
 const CONTEXTS_PATH = path.join(APP_ROOT, 'contexts');
 const SHARED_PATH = path.join(APP_ROOT, 'shared');
-const CORE_PATH = path.join(APP_ROOT, 'shared', 'core');
+const CORE_PATH = path.join(APP_ROOT, 'core');
 
 async function createDirIfNotExists(dirPath) {
     try {
@@ -25,10 +26,9 @@ async function createIndexFile(dirPath, exportPatterns = []) {
 }
 
 async function createBaseStructure(root, contextName, contextAlias) {
-    // Domain
+    // Domain - новая структура
     const domainPath = path.join(root, 'Domain');
-    await createDirIfNotExists(path.join(domainPath, 'Entities'));
-    await createDirIfNotExists(path.join(domainPath, 'Ports'));
+    await createDirIfNotExists(domainPath);
 
     // Infrastructure
     const infraPath = path.join(root, 'Infrastructure');
@@ -119,23 +119,20 @@ export default async function initStructure() {
         await createBaseStructure(contextPath, contextName, context);
     }
 
-    // Create shared structure (former core)
+    // Create empty shared folder
     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',
-        './Middleware',
-        './Translation'
-    ]);
+
+    // Create core structure with all functionality
+    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'));
+
+    // Update core index
+    await updateCoreIndex();
 
     console.log('✅ Structure initialization complete!');
 }

package/src/commands/init/initTranslations.js

@@ -1,7 +1,7 @@
-import { writeIfNotExists } from '../../utils/fileUtils.js';
+import { writeIfNotExists, updateCoreIndex } from '../../utils/fileUtils.js';
 import path from 'path';
 
-const translationsPath = path.join(process.cwd(), 'src/app/shared/Translation');
+const translationsPath = path.join(process.cwd(), 'src/app/core/Translation');
 
 const translationProviderTemplate = `import { messages } from './Locales';
 import { createTranslations } from '@azure-net/kit/i18n';
@@ -52,5 +52,8 @@ export default async function initTranslations() {
         localesIndexTemplate
     );
 
+    // Update core index
+    await updateCoreIndex();
+
     console.log('✅ Translations initialized');
 }

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 SHARED_PATH = path.join(process.cwd(), 'src/app/shared');
+const CORE_PATH = path.join(process.cwd(), 'src/app/core');
 
 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: 'shared (former core)', value: 'shared' }
+            { title: 'core', value: 'core' }
         ]
     });
 
@@ -24,8 +24,8 @@ export async function selectContext(message = 'Select context:') {
 }
 
 export function getContextPath(context) {
-    return context === 'shared'
-        ? SHARED_PATH
+    return context === 'core'
+        ? CORE_PATH
         : path.join(CONTEXTS_PATH, context);
 }
 
@@ -61,28 +61,13 @@ export async function getApplicationProviderServices(context) {
     }
 }
 
-// Fixed to preserve PascalCase properly
 export function toPascalCase(str) {
-    // If already in PascalCase with multiple words, preserve it
-    if (/^[A-Z][a-z]+(?:[A-Z][a-z]+)*$/.test(str)) {
-        return str;
-    }
-
-    // Split by common delimiters but preserve existing camelCase/PascalCase
-    const words = str.split(/[-_\s]+/);
-    return words
-        .map((word, index) => {
-            // If word is already in camelCase or PascalCase, preserve it
-            if (/[a-z][A-Z]/.test(word)) {
-                return word.charAt(0).toUpperCase() + word.slice(1);
-            }
-            // Otherwise capitalize first letter
-            return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
-        })
+    return str
+        .split(/[-_\s]+/)
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
         .join('');
 }
 
-// Fixed to preserve camelCase properly
 export function toCamelCase(str) {
     const pascal = toPascalCase(str);
     return pascal.charAt(0).toLowerCase() + pascal.slice(1);

package/src/utils/fileUtils.js

@@ -28,6 +28,34 @@ export async function updateIndexTs(dir, filePattern = '.ts', ignore = ['index.t
     }
 }
 
+export async function updateCoreIndex() {
+    const corePath = path.join(process.cwd(), 'src/app/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);
+                }
+            }
+        }
+
+        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 });