@azure-net/cli 2.0.0 → 2.0.1

package/bin/azure-net.js

@@ -7,7 +7,8 @@ import {
     initMiddleware,
     initEdges,
     initTranslations,
-    initSchema
+    initSchema,
+    initLint
 } from '../src/commands/init/index.js';
 import {
     generateDatasource,
@@ -28,6 +29,11 @@ program
     .version('2.0.0');
 
 // Init commands
+program
+    .command('init:lint')
+    .description('Setup linting and commit tools')
+    .action(initLint)
+
 program
     .command('init:structure')
     .description('Generate base folder structure')

package/package.json

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

package/src/commands/generate/generateCrud.js

@@ -2,74 +2,83 @@ 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 } from '../../utils/fileUtils.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
-\t[key: string]: unknown;
-}
-
-export type I{{name}}Collection = I{{name}}[];`;
+\tcreated_at: string;
+\tupdated_at: string;
+}`;
 
-const requestTemplate = `import type { I{{name}} } from '../../Entities/{{name}}/index.js';
+const portsIndexTemplate = `export interface I{{name}}Collection {
+\tdata: I{{name}}[];
+\ttotal: number;
+}
 
-export type I{{name}}CreateRequest = Omit<I{{name}}, 'id'>;
-export type I{{name}}UpdateRequest = Partial<I{{name}}CreateRequest>;
 export interface I{{name}}CollectionQuery {
+\tpage?: number;
+\tperPage?: number;
 \t[key: string]: unknown;
+}
+
+export interface I{{name}}CreateRequest {
+\t// Add request fields here
+}
+
+export interface I{{name}}UpdateRequest {
+\t// Add request fields here  
 }`;
 
 const repositoryTemplate = `import { {{datasource}} } from '{{datasourceImport}}';
-import type {
+import type { I{{name}} } from '${{context}}/Domain/Entities/{{name}}';
+import type { 
 \tI{{name}}Collection,
-\tI{{name}},
+\tI{{name}}CollectionQuery,
 \tI{{name}}CreateRequest,
-\tI{{name}}UpdateRequest,
-\tI{{name}}CollectionQuery
-} from '../../Domain/Entities/{{name}}/index.js';
-import type { I{{name}}CreateRequest as CreateRequest, I{{name}}UpdateRequest as UpdateRequest } from '../../Domain/Ports/{{name}}/index.js';
+\tI{{name}}UpdateRequest
+} from '${{context}}/Domain/Ports/{{name}}';
 
 export class {{name}}Repository {
 \tprivate endpoint = '{{endpoint}}';
 \t
 \tconstructor(private {{datasourceVar}}: {{datasource}}) {}
 \t
-\tpublic async collection(queryParams?: I{{name}}CollectionQuery) {
-\t\treturn await this.{{datasourceVar}}.createRequest<I{{name}}Collection>(({ http, query }) => 
-\t\t\thttp.get(\`\${this.endpoint}\${query.build(queryParams)}\`)
-\t\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 await this.{{datasourceVar}}.createRequest<I{{name}}>(({ http }) => 
+\t\treturn this.{{datasourceVar}}.createRequest<I{{name}}>(({ http }) => 
 \t\t\thttp.get(\`\${this.endpoint}/\${id}\`)
-\t\t);
+\t\t).then(res => res.getData());
 \t}
 \t
-\tpublic async create(data: CreateRequest) {
-\t\treturn await this.{{datasourceVar}}.createRequest<I{{name}}>(({ http }) => 
+\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);
+\t\t).then(res => res.getData());
 \t}
 \t
-\tpublic async update(id: number, data: UpdateRequest) {
-\t\treturn await this.{{datasourceVar}}.createRequest<I{{name}}>(({ http }) => 
+\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);
+\t\t).then(res => res.getData());
 \t}
 \t
 \tpublic async remove(id: number) {
-\t\treturn await this.{{datasourceVar}}.createRequest<never>(({ http }) => 
+\t\treturn this.{{datasourceVar}}.createRequest<void>(({ http }) => 
 \t\t\thttp.delete(\`\${this.endpoint}/\${id}\`)
-\t\t);
+\t\t).then(() => undefined);
 \t}
 }`;
 
 const serviceTemplate = `import { ClassMirror } from '@azure-net/kit';
-import { {{name}}Repository } from '../../Infrastructure/Repositories/index.js';
+import { {{name}}Repository } from '../../Infrastructure/Http/Repositories';
 
 export class {{name}}Service extends ClassMirror<{{name}}Repository> {
 \tconstructor(private {{camelName}}Repository: {{name}}Repository) {
@@ -84,7 +93,7 @@ export class {{name}}Service extends ClassMirror<{{name}}Repository> {
 }`;
 
 const createSchemaTemplate = `import { {{schemaFactory}} } from '{{schemaImport}}';
-import type { I{{name}}CreateRequest } from '../../Domain/Ports/{{name}}/index.js';
+import type { I{{name}}CreateRequest } from '${{context}}/Domain/Ports/{{name}}';
 
 export const Create{{name}}Schema = {{schemaFactory}}<I{{name}}CreateRequest>()
 \t.rules((rules) => ({
@@ -93,7 +102,7 @@ export const Create{{name}}Schema = {{schemaFactory}}<I{{name}}CreateRequest>()
 \t.create();`;
 
 const updateSchemaTemplate = `import { {{schemaFactory}} } from '{{schemaImport}}';
-import type { I{{name}}UpdateRequest } from '../../Domain/Ports/{{name}}/index.js';
+import type { I{{name}}UpdateRequest } from '${{context}}/Domain/Ports/{{name}}';
 
 export const Update{{name}}Schema = {{schemaFactory}}<I{{name}}UpdateRequest>()
 \t.rules((rules) => ({
@@ -102,15 +111,19 @@ export const Update{{name}}Schema = {{schemaFactory}}<I{{name}}UpdateRequest>()
 \t.create();`;
 
 const presenterTemplate = `import { {{presenterFactory}} } from '{{presenterImport}}';
-import { ApplicationProvider } from '../../Application/index.js';
-import { Create{{name}}Schema, Update{{name}}Schema } from '../Schemas/index.js';
-import type { I{{name}}CreateRequest, I{{name}}UpdateRequest, I{{name}}CollectionQuery } from '../../Domain/Ports/{{name}}/index.js';
+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 {{contextName}}{{name}}Presenter = {{presenterFactory}}('{{contextName}}{{name}}Presenter', ({ createAsyncResource, createAsyncAction }) => {
+export const {{name}}Presenter = {{presenterFactory}}('{{name}}Presenter', ({ createAsyncResource, createAsyncAction }) => {
 \tconst { {{name}}Service } = ApplicationProvider();
 \t
-\tconst collection = async (queryParams?: I{{name}}CollectionQuery) => 
-\t\tawait createAsyncResource({{name}}Service.collection(queryParams));
+\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));
@@ -150,15 +163,15 @@ export default async function generateCrud() {
     // Get available datasources
     const contextPath = getContextPath(context);
     const coreDatasources = await getAvailableFiles(
-        path.join(process.cwd(), 'src/app/core/Datasources')
+        path.join(process.cwd(), 'src/app/core/Datasource')
     );
     const contextDatasources = await getAvailableFiles(
-        path.join(contextPath, 'Infrastructure', 'Datasources')
+        path.join(contextPath, 'Infrastructure/Http/Datasource')
     );
 
     const allDatasources = [
-        ...coreDatasources.map(d => ({ title: `${d}Datasource (core)`, value: { name: `${d}Datasource`, from: 'core' } })),
-        ...contextDatasources.map(d => ({ title: `${d}Datasource (${context})`, value: { name: `${d}Datasource`, from: context } }))
+        ...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({
@@ -170,7 +183,7 @@ export default async function generateCrud() {
 
     // Get schema and presenter factories
     const coreSchemas = await getAvailableFiles(
-        path.join(process.cwd(), 'src/app/core/Schemas')
+        path.join(process.cwd(), 'src/app/core/Schema')
     );
 
     const { schemaType } = await prompts({
@@ -178,13 +191,13 @@ export default async function generateCrud() {
         name: 'schemaType',
         message: 'Select schema factory:',
         choices: [
-            { title: 'Use schema from package', value: 'package' },
+            { 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/Presenters')
+        path.join(process.cwd(), 'src/app/core/Presenter')
     );
 
     const { presenterType } = await prompts({
@@ -210,23 +223,26 @@ export default async function generateCrud() {
         entityTemplate.replace(/{{name}}/g, pascalName)
     );
 
-    // 2. Create Ports (Requests/Responses)
+    // 2. Create Ports
     const portsPath = path.join(contextPath, 'Domain', 'Ports', pascalName);
     await writeIfNotExists(
         path.join(portsPath, 'index.ts'),
-        requestTemplate.replace(/{{name}}/g, pascalName)
+        portsIndexTemplate
+            .replace(/{{name}}/g, pascalName)
+            .replace(/{{context}}/g, context)
     );
 
     // 3. Create Repository
-    const repoPath = path.join(contextPath, 'Infrastructure', 'Repositories');
+    const repoPath = path.join(contextPath, 'Infrastructure', 'Http', 'Repositories');
     const datasourceImport = datasource.from === 'core'
-        ? '$core/Datasources/index.js'
-        : '../Datasources/index.js';
+        ? '$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)
@@ -244,17 +260,21 @@ export default async function generateCrud() {
     );
     await updateIndexTs(servicePath);
 
-    // 5. Create Schemas
-    const schemaPath = path.join(contextPath, 'Delivery', 'Schemas');
-    const schemaFactory = schemaType === 'package' ? 'schema' : schemaType;
+    // 5. Create Delivery module structure
+    const deliveryModulePath = path.join(contextPath, 'Delivery', pascalName);
+    const schemaPath = path.join(deliveryModulePath, 'Schema');
+
+    // Create schemas
+    const schemaFactory = schemaType === 'package' ? 'createSchemaFactory' : schemaType;
     const schemaImport = schemaType === 'package'
         ? '@azure-net/kit'
-        : '$core/Schemas/index.js';
+        : '$core/Schema';
 
     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)
     );
@@ -263,61 +283,68 @@ export default async function generateCrud() {
         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
-    const presenterPath = path.join(contextPath, 'Delivery', 'Presenters');
     const presenterFactory = presenterType === 'package' ? 'createPresenter' : presenterType;
     const presenterImport = presenterType === 'package'
         ? '@azure-net/kit'
-        : '$core/Presenters/index.js';
+        : '$core/Presenter';
 
     await writeIfNotExists(
-        path.join(presenterPath, `${pascalName}Presenter.ts`),
+        path.join(deliveryModulePath, `${pascalName}Presenter.ts`),
         presenterTemplate
             .replace(/{{name}}/g, pascalName)
-            .replace(/{{contextName}}/g, contextName)
+            .replace(/{{context}}/g, context)
             .replace(/{{presenterFactory}}/g, presenterFactory)
             .replace(/{{presenterImport}}/g, presenterImport)
     );
-    await updateIndexTs(presenterPath);
+
+    // Create module index
+    await writeIfNotExists(
+        path.join(deliveryModulePath, 'index.ts'),
+        `export * from './${pascalName}Presenter';\nexport * from './Schema';`
+    );
 
     // 7. Setup Providers
     // Ensure DatasourceProvider
-    await ensureProvider(context, 'Infrastructure', { datasource: datasource.name });
+    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
+    // Ensure InfrastructureProvider
     const infraProvider = await ensureProvider(context, 'Infrastructure', {});
     await addToProvider(
         infraProvider.path,
         `${pascalName}Repository`,
-        '../Repositories/index.js'
+        '../Http/Repositories',
+        `DatasourceProvider.${datasource.name}`
     );
 
-    // Update provider with datasource dependency
-    let infraContent = await fs.readFile(infraProvider.path, 'utf-8');
-    const repoFactory = `${pascalName}Repository: () => new ${pascalName}Repository()`;
-    const repoWithDatasource = `${pascalName}Repository: () => new ${pascalName}Repository(DatasourceProvider.${datasource.name})`;
-    infraContent = infraContent.replace(repoFactory, repoWithDatasource);
-    await fs.writeFile(infraProvider.path, infraContent, 'utf-8');
-
-    // Ensure ApplicationProvider and add service
+    // Ensure ApplicationProvider
     const appProvider = await ensureProvider(context, 'Application', { infrastructure: true });
     await addToProvider(
         appProvider.path,
         `${pascalName}Service`,
-        '../Services/index.js'
+        '../Services',
+        `InfrastructureProvider.${pascalName}Repository`
     );
 
-    // Update provider with repository dependency
-    let appContent = await fs.readFile(appProvider.path, 'utf-8');
-    const serviceFactory = `${pascalName}Service: () => new ${pascalName}Service()`;
-    const serviceWithRepo = `${pascalName}Service: () => new ${pascalName}Service(InfrastructureProvider.${pascalName}Repository)`;
-    appContent = appContent.replace(serviceFactory, serviceWithRepo);
-    await fs.writeFile(appProvider.path, appContent, 'utf-8');
+    // Update all layer indexes
+    await ensureIndexExports(path.join(contextPath, 'Infrastructure'));
+    await ensureIndexExports(path.join(contextPath, 'Application'));
 
     console.log(`✅ CRUD module for ${pascalName} created successfully!`);
 }

package/src/commands/generate/generateDatasource.js

@@ -3,11 +3,16 @@ import { selectContext, getContextPath, toPascalCase } from '../../utils/context
 import { writeIfNotExists, updateIndexTs } from '../../utils/fileUtils.js';
 import path from 'path';
 
-const datasourceTemplate = `import { BaseHttpDatasource, HttpService } from '@azure-net/kit';
+const datasourceTemplate = `import { BaseHttpDatasource } from '@azure-net/kit/infra';
+import { HttpService } from '@azure-net/kit/infra';
 
 export class {{name}}Datasource extends BaseHttpDatasource {
 \tconstructor() {
-\t\tsuper({ http: new HttpService({ baseUrl: '' }) });
+\t\tsuper({ 
+\t\t\thttp: new HttpService({ 
+\t\t\t\tbaseUrl: 'https://api.example.com'
+\t\t\t}) 
+\t\t});
 \t}
 }`;
 
@@ -17,14 +22,14 @@ export default async function generateDatasource() {
     const { name } = await prompts({
         type: 'text',
         name: 'name',
-        message: 'Datasource name (PascalCase):'
+        message: 'Datasource name (without "Datasource" suffix):'
     });
 
     const pascalName = toPascalCase(name);
     const contextPath = getContextPath(context);
     const datasourcePath = context === 'core'
-        ? path.join(contextPath, 'Datasources')
-        : path.join(contextPath, 'Infrastructure', 'Datasources');
+        ? path.join(contextPath, 'Datasource')
+        : path.join(contextPath, 'Infrastructure', 'Http', 'Datasource');
 
     const content = datasourceTemplate.replace(/{{name}}/g, pascalName);
     const filePath = path.join(datasourcePath, `${pascalName}Datasource.ts`);

package/src/commands/generate/generatePresenter.js

@@ -3,15 +3,15 @@ import path from 'path';
 import { selectContext, getContextPath, toPascalCase, getAvailableFiles } from '../../utils/contextUtils.js';
 import { writeIfNotExists, updateIndexTs } from '../../utils/fileUtils.js';
 
-const presenterWithCoreTemplate = `import { {{corePresenter}} } from '$core/Presenters/index.js';
+const presenterWithCoreTemplate = `import { {{corePresenter}} } from '$core/Presenter';
 {{serviceImport}}
 
-export const {{contextName}}{{name}}Presenter = {{corePresenter}}('{{contextName}}{{name}}Presenter', ({ createAsyncResource, createAsyncAction }) => {
+export const {{name}}Presenter = {{corePresenter}}('{{name}}Presenter', ({ createAsyncResource, createAsyncAction }) => {
 \t{{serviceInit}}
 \t
 \tconst example = async () => {
 \t\t// Implement presenter logic
-\t\treturn {};
+\t\treturn await createAsyncResource(Promise.resolve({}));
 \t};
 \t
 \treturn { example };
@@ -20,7 +20,7 @@ export const {{contextName}}{{name}}Presenter = {{corePresenter}}('{{contextName
 const presenterWithPackageTemplate = `import { createPresenter } from '@azure-net/kit';
 {{serviceImport}}
 
-export const {{contextName}}{{name}}Presenter = createPresenter('{{contextName}}{{name}}Presenter', () => {
+export const {{name}}Presenter = createPresenter('{{name}}Presenter', () => {
 \t{{serviceInit}}
 \t
 \tconst example = async () => {
@@ -42,12 +42,12 @@ export default async function generatePresenter() {
     const { name } = await prompts({
         type: 'text',
         name: 'name',
-        message: 'Presenter name (without "Presenter" suffix):'
+        message: 'Module name (will create folder in Delivery):'
     });
 
     // Check for core presenters
     const corePresenters = await getAvailableFiles(
-        path.join(process.cwd(), 'src/app/core/Presenters')
+        path.join(process.cwd(), 'src/app/core/Presenter')
     );
 
     const presenterChoices = [
@@ -70,7 +70,7 @@ export default async function generatePresenter() {
 
     const serviceChoices = [
         { title: 'Without service', value: null },
-        ...services.map(s => ({ title: `${s}Service`, value: `${s}Service` }))
+        ...services.map(s => ({ title: `${s}`, value: s }))
     ];
 
     const { service } = await prompts({
@@ -81,12 +81,11 @@ export default async function generatePresenter() {
     });
 
     const pascalName = toPascalCase(name);
-    const contextName = toPascalCase(context);
-    const presenterPath = path.join(contextPath, 'Delivery', 'Presenters');
-    const filePath = path.join(presenterPath, `${pascalName}Presenter.ts`);
+    const modulePath = path.join(contextPath, 'Delivery', pascalName);
+    const filePath = path.join(modulePath, `${pascalName}Presenter.ts`);
 
     const serviceImport = service
-        ? `import { ApplicationProvider } from '../../Application/index.js';`
+        ? `import { ApplicationProvider } from '$${context}/Application';`
         : '';
 
     const serviceInit = service
@@ -95,19 +94,20 @@ export default async function generatePresenter() {
 
     const content = presenterType === 'package'
         ? presenterWithPackageTemplate
-            .replace(/{{contextName}}/g, contextName)
             .replace(/{{name}}/g, pascalName)
             .replace(/{{serviceImport}}/g, serviceImport)
             .replace(/{{serviceInit}}/g, serviceInit)
         : presenterWithCoreTemplate
-            .replace(/{{contextName}}/g, contextName)
             .replace(/{{name}}/g, pascalName)
             .replace(/{{corePresenter}}/g, presenterType)
             .replace(/{{serviceImport}}/g, serviceImport)
             .replace(/{{serviceInit}}/g, serviceInit);
 
     await writeIfNotExists(filePath, content);
-    await updateIndexTs(presenterPath);
+    await writeIfNotExists(
+        path.join(modulePath, 'index.ts'),
+        `export * from './${pascalName}Presenter';`
+    );
 
     console.log(`✅ Presenter created at ${filePath}`);
 }

package/src/commands/generate/generateRepository.js

@@ -1,7 +1,7 @@
 import prompts from 'prompts';
 import fs from 'fs/promises';
 import path from 'path';
-import { selectContext, getContextPath, toPascalCase, getAvailableFiles } from '../../utils/contextUtils.js';
+import { selectContext, getContextPath, toPascalCase, getAvailableFiles, toCamelCase } from '../../utils/contextUtils.js';
 import { writeIfNotExists, updateIndexTs } from '../../utils/fileUtils.js';
 import { ensureProvider, addToProvider } from '../../utils/providerUtils.js';
 
@@ -34,15 +34,15 @@ export default async function generateRepository() {
     // Get available datasources
     const contextPath = getContextPath(context);
     const coreDatasources = await getAvailableFiles(
-        path.join(process.cwd(), 'src/app/core/Datasources')
+        path.join(process.cwd(), 'src/app/core/Datasource')
     );
     const contextDatasources = await getAvailableFiles(
-        path.join(contextPath, 'Infrastructure', 'Datasources')
+        path.join(contextPath, 'Infrastructure', 'Http', 'Datasource')
     );
 
     const allDatasources = [
-        ...coreDatasources.map(d => ({ title: `${d}Datasource (core)`, value: { name: `${d}Datasource`, from: 'core' } })),
-        ...contextDatasources.map(d => ({ title: `${d}Datasource (${context})`, value: { name: `${d}Datasource`, from: context } }))
+        ...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) {
@@ -58,40 +58,45 @@ export default async function generateRepository() {
     });
 
     const pascalName = toPascalCase(name);
-    const repoPath = path.join(contextPath, 'Infrastructure', 'Repositories');
+    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/Datasources/index.js'
-        : '../Datasources/index.js';
+        ? '$core/Datasource'
+        : '../Datasource';
 
     const content = repositoryTemplate
         .replace(/{{name}}/g, pascalName)
         .replace(/{{datasource}}/g, datasource.name)
         .replace(/{{datasourceImport}}/g, datasourceImport)
-        .replace(/{{datasourceVar}}/g, toPascalCase(datasource.name).charAt(0).toLowerCase() + toPascalCase(datasource.name).slice(1));
+        .replace(/{{datasourceVar}}/g, toCamelCase(datasource.name));
 
     await writeIfNotExists(filePath, content);
     await updateIndexTs(repoPath);
 
     // Ensure DatasourceProvider exists
-    const datasourceProvider = await ensureProvider(context, 'Infrastructure', { datasource: datasource.name });
+    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 exists and add repository
-    const infraProvider = await ensureProvider(context, 'Infrastructure', { datasource: datasource.name });
+    // Ensure InfrastructureProvider and add repository
+    const infraProvider = await ensureProvider(context, 'Infrastructure', { hasDatasource: true });
     await addToProvider(
         infraProvider.path,
         `${pascalName}Repository`,
-        '../Repositories/index.js'
+        '../Http/Repositories',
+        `DatasourceProvider.${datasource.name}`
     );
 
-    // Add datasource dependency to repository in provider
-    let providerContent = await fs.readFile(infraProvider.path, 'utf-8');
-    const repoFactory = `${pascalName}Repository: () => new ${pascalName}Repository()`;
-    const repoWithDatasource = `${pascalName}Repository: () => new ${pascalName}Repository(DatasourceProvider.${datasource.name})`;
-    providerContent = providerContent.replace(repoFactory, repoWithDatasource);
-    await fs.writeFile(infraProvider.path, providerContent, 'utf-8');
-
     console.log(`✅ Repository created at ${filePath}`);
 }

package/src/commands/generate/generateSchema.js

@@ -3,8 +3,8 @@ 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/Schemas/index.js';
-import type { I{{name}}Request } from '../../Domain/Ports/{{name}}/index.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) => ({
@@ -12,10 +12,13 @@ export const {{name}}Schema = {{coreSchema}}<I{{name}}Request>()
 \t}))
 \t.create();`;
 
-const schemaWithPackageTemplate = `import { schema } from '@azure-net/kit';
-import type { I{{name}}Request } from '../../Domain/Ports/{{name}}/index.js';
+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}}';
 
-export const {{name}}Schema = schema<I{{name}}Request>()
+const Schema = createSchemaFactory(createRules(validationMessagesI18n));
+
+export const {{name}}Schema = Schema<I{{name}}Request>()
 \t.rules((rules) => ({
 \t\t// Add validation rules here
 \t}))
@@ -29,6 +32,12 @@ export default async function generateSchema() {
         return;
     }
 
+    const { module } = await prompts({
+        type: 'text',
+        name: 'module',
+        message: 'Module name (folder in Delivery):'
+    });
+
     const { name } = await prompts({
         type: 'text',
         name: 'name',
@@ -37,11 +46,11 @@ export default async function generateSchema() {
 
     // Check for core schemas
     const coreSchemas = await getAvailableFiles(
-        path.join(process.cwd(), 'src/app/core/Schemas')
+        path.join(process.cwd(), 'src/app/core/Schema')
     );
 
     const choices = [
-        { title: 'Use schema from package', value: 'package' },
+        { title: 'Use createSchemaFactory from package', value: 'package' },
         ...coreSchemas.map(s => ({ title: `Use ${s} from core`, value: s }))
     ];
 
@@ -53,18 +62,34 @@ export default async function generateSchema() {
     });
 
     const pascalName = toPascalCase(name);
+    const moduleName = toPascalCase(module);
     const contextPath = getContextPath(context);
-    const schemaPath = path.join(contextPath, 'Delivery', 'Schemas');
+    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)
+        ? 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/init/index.js

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

package/src/commands/init/initLint.js

@@ -0,0 +1,138 @@
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import prompts from 'prompts';
+
+const dependencies = [
+    '@commitlint/cli',
+    'semantic-release',
+    '@semantic-release/git',
+    'git-cz',
+    'husky',
+    'commitizen',
+    'env-cmd'
+];
+
+const scriptsToAdd = {
+    precommit: 'pnpm lint && pnpm check',
+    'semantic-release': 'env-cmd semantic-release',
+    commit: 'pnpm format && git add . && git-cz && git push',
+    release: 'pnpm commit && pnpm semantic-release'
+};
+
+const commitlintConfig = `export default {
+	rules: {
+		'body-leading-blank': [2, 'always'],
+		'footer-leading-blank': [2, 'always'],
+		'header-max-length': [2, 'always', 72],
+		'subject-empty': [2, 'never'],
+		'subject-full-stop': [2, 'never', '.'],
+		'type-case': [2, 'always', 'lower-case'],
+		'type-empty': [2, 'never'],
+		'type-enum': [2, 'always', ['feat', 'fix', 'refactor', 'perf', 'chore', 'docs', 'style', 'test', 'ci']]
+	}
+};
+`;
+
+const releaseConfig = `export default {
+	branches: ['main', 'dev'],
+	dryRun: false,
+	ci: false,
+	plugins: [
+		[
+			'@semantic-release/commit-analyzer',
+			{
+				releaseRules: [
+					{ type: 'release', release: 'major' },
+					{ type: 'feature', release: 'minor' },
+					{ type: 'perf', release: false },
+					{ type: 'refactor', release: false },
+					{ type: 'fix', release: 'patch' },
+					{ type: 'chore', release: false },
+					{ type: 'ci', release: false },
+					{ type: 'docs', scope: 'README', release: false },
+					{ type: 'test', release: false },
+					{ type: 'style', release: false }
+				]
+			}
+		],
+		'@semantic-release/release-notes-generator'
+	]
+};
+`;
+
+const prettierConfig = `{
+	"useTabs": true,
+	"singleQuote": true,
+	"trailingComma": "none",
+	"tabWidth": 2,
+	"semi": true,
+	"printWidth": 150,
+	"plugins": ["prettier-plugin-svelte"],
+	"overrides": [
+		{
+			"files": "*.svelte",
+			"options": {
+				"parser": "svelte"
+			}
+		}
+	]
+}
+`;
+
+export default async function initLint() {
+    const cwd = process.cwd();
+    const pkgPath = path.join(cwd, 'package.json');
+
+    if (!fs.existsSync(pkgPath)) {
+        console.error('❌ package.json not found in this directory');
+        process.exit(1);
+    }
+
+    const { manager } = await prompts({
+        type: 'select',
+        name: 'manager',
+        message: 'Choose your package manager:',
+        choices: [
+            { title: 'pnpm', value: 'pnpm' },
+            { title: 'npm', value: 'npm' },
+            { title: 'yarn', value: 'yarn' }
+        ],
+        initial: 0
+    });
+
+    const installCommand =
+        manager === 'pnpm'
+            ? `pnpm add -D ${dependencies.join(' ')}`
+            : manager === 'npm'
+                ? `npm install -D ${dependencies.join(' ')}`
+                : `yarn add -D ${dependencies.join(' ')}`;
+
+    console.log(`📦 Installing packages with ${manager}...`);
+    execSync(installCommand, { stdio: 'inherit' });
+
+    console.log('📁 Updating package.json...');
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+
+    pkg.scripts = {
+        ...pkg.scripts,
+        ...scriptsToAdd
+    };
+
+    pkg.config = pkg.config || {};
+    pkg.config.commitizen = {
+        path: 'git-cz'
+    };
+
+    fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 4));
+
+    // Write config files
+    fs.writeFileSync(path.join(cwd, 'commitlint.config.ts'), commitlintConfig);
+    fs.writeFileSync(path.join(cwd, 'release.config.ts'), releaseConfig);
+    fs.writeFileSync(path.join(cwd, '.prettierrc'), prettierConfig);
+
+    console.log('🔧 Initializing Husky...');
+    execSync(`${manager === 'npm' ? 'npx' : manager} husky`, { stdio: 'inherit' });
+    execSync('npm run format', { stdio: 'inherit' });
+    console.log('✅ Linting and release setup completed! Change your prepare script in package.json: node -e \"if (process.env.NODE_ENV !== \'production\'){process.exit(1)} \" || (husky && svelte-kit sync)');
+}

package/src/commands/init/initMiddleware.js

@@ -5,37 +5,22 @@ const middlewarePath = path.join(process.cwd(), 'src/app/core/Middleware/Middlew
 const hooksServerPath = path.join(process.cwd(), 'src/hooks.server.ts');
 const layoutPath = path.join(process.cwd(), 'src/routes/+layout.svelte');
 
-const middlewareTemplate = `import { createMiddlewareManager, type IMiddleware } from '@azure-net/kit';
-
-const AuthMiddleware: IMiddleware = async ({ next, page, event, isServer, cookies }) => {
-\tconst user = isServer ? event?.locals?.user : page?.data?.user;
-\tif (isServer && !user && cookies.get('token') && event) {
-\t\t// Add auth logic here
-\t}
-\tnext();
-};
-
-const GuardMiddleware: IMiddleware = async ({ next, page, event, isServer, to }) => {
-\tconst user = isServer ? event?.locals?.user : page?.data?.user;
-\tif (!user && !to.pathname.startsWith('/login')) {
-\t\tnext('/login');
-\t}
-\tif (user && to.pathname.startsWith('/login')) {
-\t\tnext('/');
-\t}
-\tnext();
-};
-
-export const { clientMiddleware, serverMiddleware } = createMiddlewareManager([AuthMiddleware, GuardMiddleware]);`;
+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 { serverMiddleware } from '$core/Middleware/index.js';`,
         'import',
+        `import { serverMiddleware } from '$core';`,
         'before'
     );
 
@@ -50,7 +35,7 @@ export default async function initMiddleware() {
     await injectIntoFile(
         layoutPath,
         '<script',
-        `\timport { clientMiddleware } from '$core/Middleware/index.js';\n\tclientMiddleware();`,
+        `\timport { clientMiddleware } from '$core';\n\tclientMiddleware();`,
         'after'
     );
 

package/src/commands/init/initSchema.js

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

package/src/commands/init/initStructure.js

@@ -2,7 +2,6 @@ import fs from 'fs/promises';
 import path from 'path';
 import { loadUserConfig } from '../../utils/loadConfig.js';
 
-const BASE_STRUCTURE = ['Domain', 'Infrastructure', 'Application', 'Delivery'];
 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');
@@ -16,31 +15,34 @@ async function createDirIfNotExists(dirPath) {
     }
 }
 
+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) {
-    for (const section of BASE_STRUCTURE) {
-        const sectionPath = path.join(root, section);
-        await createDirIfNotExists(sectionPath);
+    // Domain
+    const domainPath = path.join(root, 'Domain');
+    await createDirIfNotExists(path.join(domainPath, 'Entities'));
+    await createDirIfNotExists(path.join(domainPath, 'Ports'));
 
-        if (section === 'Infrastructure') {
-            await createDirIfNotExists(path.join(sectionPath, 'Repositories'));
-            await createDirIfNotExists(path.join(sectionPath, 'Datasources'));
-            await createDirIfNotExists(path.join(sectionPath, 'Providers'));
-        }
-        if (section === 'Application') {
-            await createDirIfNotExists(path.join(sectionPath, 'Services'));
-            await createDirIfNotExists(path.join(sectionPath, 'Providers'));
-        }
-        if (section === 'Domain') {
-            await createDirIfNotExists(path.join(sectionPath, 'Entities'));
-            await createDirIfNotExists(path.join(sectionPath, 'Ports'));
-        }
-        if (section === 'Delivery') {
-            await createDirIfNotExists(path.join(sectionPath, 'Presenters'));
-            await createDirIfNotExists(path.join(sectionPath, 'Schemas'));
-            await createDirIfNotExists(path.join(sectionPath, 'Actions'));
-            await createDirIfNotExists(path.join(sectionPath, 'Stores'));
-        }
-    }
+    // 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() {
@@ -57,12 +59,21 @@ export default async function initStructure() {
 
     // Create core structure
     await createDirIfNotExists(CORE_PATH);
-    await createDirIfNotExists(path.join(CORE_PATH, 'Datasources'));
-    await createDirIfNotExists(path.join(CORE_PATH, 'Responses'));
-    await createDirIfNotExists(path.join(CORE_PATH, 'Schemas'));
+    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, 'Presenters'));
-    await createDirIfNotExists(path.join(CORE_PATH, 'Translations'));
+    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!');
 }

package/src/commands/init/initTranslations.js

@@ -1,11 +1,11 @@
 import { writeIfNotExists, updateIndexTs, injectIntoFile } from '../../utils/fileUtils.js';
 import path from 'path';
 
-const translationsPath = path.join(process.cwd(), 'src/app/core/Translations');
+const translationsPath = path.join(process.cwd(), 'src/app/core/Translation');
 const layoutServerPath = path.join(process.cwd(), 'src/routes/+layout.server.ts');
 const layoutTsPath = path.join(process.cwd(), 'src/routes/+layout.ts');
 
-const translationProviderTemplate = `import { messages } from './Locales/index.js';
+const translationProviderTemplate = `import { messages } from './Locales';
 import { createTranslations } from '@azure-net/kit/i18n';
 
 export const Translation = createTranslations({ 
@@ -28,8 +28,8 @@ const ruLocaleTemplate = `export default {
 };`;
 
 const localesIndexTemplate = `export const messages = {
-\ten: () => import('./en.js').then((res) => res.default),
-\tru: () => import('./ru.js').then((res) => res.default)
+\ten: () => import('./en').then((res) => res.default),
+\tru: () => import('./ru').then((res) => res.default)
 };`;
 
 export default async function initTranslations() {
@@ -54,13 +54,11 @@ export default async function initTranslations() {
         localesIndexTemplate
     );
 
-    await updateIndexTs(translationsPath);
-
     // Add to hooks.server.ts
     await injectIntoFile(
         path.join(process.cwd(), 'src/hooks.server.ts'),
         'import',
-        `import { Translation } from '$core/Translations/index.js';`,
+        `import { Translation } from '$core';`,
         'before'
     );
 
@@ -71,18 +69,25 @@ export default async function initTranslations() {
         'after'
     );
 
+    await injectIntoFile(
+        path.join(process.cwd(), 'src/hooks.server.ts'),
+        'transformPageChunk: ({ html })',
+        ' => {\n\t\t\t\tconst serialized = serialize(html);\n\t\t\t\treturn applyHtmlLocaleAttr(serialized);\n\t\t\t}',
+        'after'
+    );
+
     // Add to layout files
     await injectIntoFile(
         layoutServerPath,
         'export const load',
-        `\treturn { lang: locals.lang, user: locals.user };`,
+        `\treturn { lang: locals.lang };`,
         'after'
     );
 
     await injectIntoFile(
         layoutTsPath,
         'import',
-        `import { Translation } from '$core/Translations/index.js';`,
+        `import { Translation } from '$core';\nimport { browser } from '$app/environment';`,
         'before'
     );
 

package/src/utils/fileUtils.js

@@ -20,7 +20,7 @@ export async function updateIndexTs(dir, filePattern = '.ts', ignore = ['index.t
             f.endsWith(filePattern) && !ignore.includes(f)
         );
         const content = files
-            .map(f => `export * from './${f.replace('.ts', '')}.js';`)
+            .map(f => `export * from './${f.replace('.ts', '')}';`)
             .join('\n') + '\n';
         await fs.writeFile(path.join(dir, 'index.ts'), content, 'utf-8');
     } catch (error) {
@@ -28,6 +28,25 @@ export async function updateIndexTs(dir, filePattern = '.ts', ignore = ['index.t
     }
 }
 
+export async function ensureIndexExports(layerPath) {
+    try {
+        const subdirs = await fs.readdir(layerPath, { withFileTypes: true });
+        const exportLines = subdirs
+            .filter(d => d.isDirectory())
+            .map(d => `export * from './${d.name}';`);
+
+        if (exportLines.length > 0) {
+            await fs.writeFile(
+                path.join(layerPath, 'index.ts'),
+                exportLines.join('\n') + '\n',
+                'utf-8'
+            );
+        }
+    } catch (error) {
+        // Directory doesn't exist
+    }
+}
+
 export async function injectIntoFile(filepath, searchPattern, newContent, position = 'after') {
     try {
         let content = await fs.readFile(filepath, 'utf-8');

package/src/utils/providerUtils.js

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