@azure-net/cli 4.0.0-0 → 4.0.0-1

package/src/utils/contextUtils.ts

@@ -0,0 +1,89 @@
+import fs from 'fs/promises';
+import path from 'path';
+import prompts from 'prompts';
+import { loadUserConfig } from './loadConfig.js';
+
+const APP_PATH = path.join(process.cwd(), 'src/app');
+const CORE_PATH = path.join(process.cwd(), 'src/core');
+
+function normalizeContextNames(rawContexts: unknown): string[] {
+	if (!Array.isArray(rawContexts)) return [];
+
+	return rawContexts
+		.map((item) => {
+			if (typeof item === 'string') {
+				return item.trim();
+			}
+			if (!item || typeof item !== 'object') return '';
+			return String(item.name ?? '').trim();
+		})
+		.filter(Boolean);
+}
+
+export async function selectContext(message = 'Select context:'): Promise<string | null> {
+	const config = await loadUserConfig();
+	const contexts = normalizeContextNames(config.contexts);
+
+	const { context } = await prompts({
+		type: 'select',
+		name: 'context',
+		message,
+		choices: [...contexts.map((c) => ({ title: c, value: c })), { title: 'core', value: 'core' }]
+	});
+
+	return context ? String(context) : null;
+}
+
+export function getContextPath(context: string): string {
+	return context === 'core' ? CORE_PATH : path.join(APP_PATH, context, 'layers');
+}
+
+export async function getAvailableFiles(dir: string, pattern = '.ts'): Promise<string[]> {
+	try {
+		const files = await fs.readdir(dir);
+		return files.filter((f) => f.endsWith(pattern) && f !== 'index.ts').map((f) => f.replace(pattern, ''));
+	} catch {
+		return [];
+	}
+}
+
+export async function getApplicationProviderServices(context: string): Promise<string[]> {
+	const contextPath = getContextPath(context);
+	const providerPath = path.join(contextPath, 'application/providers/ApplicationProvider.ts');
+
+	try {
+		const content = await fs.readFile(providerPath, 'utf-8');
+		// Extract service names from ApplicationProvider
+		const serviceRegex = /(\w+Service):\s*\(/g;
+		const services: string[] = [];
+		let match;
+
+		while ((match = serviceRegex.exec(content)) !== null) {
+			const serviceName = match[1];
+			if (serviceName) services.push(serviceName);
+		}
+
+		return services;
+	} catch {
+		return [];
+	}
+}
+
+export function toPascalCase(str: string): string {
+	return str
+		.split(/[-_\s]+/)
+		.map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+		.join('');
+}
+
+export function toCamelCase(str: string): string {
+	const pascal = toPascalCase(str);
+	return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+
+export function toKebabCase(str: string): string {
+	return str
+		.replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+		.replace(/([A-Z])([A-Z][a-z])/g, '$1-$2')
+		.toLowerCase();
+}

package/src/utils/fileUtils.ts

@@ -0,0 +1,100 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+export async function writeIfNotExists(filepath: string, content: string): Promise<boolean> {
+	try {
+		await fs.access(filepath);
+		console.log(`⚠️  Skip existing: ${filepath}`);
+		return false;
+	} catch {
+		await fs.mkdir(path.dirname(filepath), { recursive: true });
+		await fs.writeFile(filepath, content, 'utf-8');
+		console.log(`✅ Created: ${filepath}`);
+		return true;
+	}
+}
+
+export async function updateIndexTs(dir: string, filePattern = '.ts', ignore: string[] = ['index.ts']): Promise<void> {
+	try {
+		const files = (await fs.readdir(dir)).filter((f) => f.endsWith(filePattern) && !ignore.includes(f));
+		const content = files.map((f) => `export * from './${f.replace('.ts', '')}';`).join('\n') + '\n';
+		await fs.writeFile(path.join(dir, 'index.ts'), content, 'utf-8');
+	} catch {
+		// Directory doesn't exist yet
+	}
+}
+
+export async function updateCoreIndex(): Promise<void> {
+	const corePath = path.join(process.cwd(), 'src/core');
+	try {
+		const dirs = await fs.readdir(corePath, { withFileTypes: true });
+		const validDirs: string[] = [];
+
+		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 {
+		// Core directory doesn't exist
+	}
+}
+
+export async function ensureIndexExports(layerPath: string): Promise<void> {
+	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 {
+		// Directory doesn't exist
+	}
+}
+
+export async function injectIntoFile(
+	filepath: string,
+	searchPattern: string,
+	newContent: string,
+	position: 'after' | 'before' = 'after'
+): Promise<boolean> {
+	try {
+		let content = await fs.readFile(filepath, 'utf-8');
+		const index = content.indexOf(searchPattern);
+
+		if (index === -1) {
+			console.warn(`Pattern not found in ${filepath}`);
+			return false;
+		}
+
+		if (content.includes(newContent.trim())) {
+			console.log(`Content already exists in ${filepath}`);
+			return false;
+		}
+
+		if (position === 'after') {
+			const insertIndex = index + searchPattern.length;
+			content = content.slice(0, insertIndex) + '\n' + newContent + content.slice(insertIndex);
+		} else {
+			content = content.slice(0, index) + newContent + '\n' + content.slice(index);
+		}
+
+		await fs.writeFile(filepath, content, 'utf-8');
+		console.log(`✅ Updated: ${filepath}`);
+		return true;
+	} catch (error: unknown) {
+		console.error(`Failed to update ${filepath}:`, error instanceof Error ? error.message : String(error));
+		return false;
+	}
+}

package/src/utils/loadConfig.ts

@@ -0,0 +1,69 @@
+import fs from 'node:fs/promises';
+import fsSync from 'node:fs';
+import path from 'node:path';
+
+export type AzureNetConfig = {
+	contexts: Array<string | { name?: string; alias?: string }>;
+	defaultContext: string;
+	coreAlias: string;
+	sharedAlias?: string;
+	packageManager?: string;
+	defaultSchemaFactory?: string;
+	defaultPresenterFactory?: string;
+	[key: string]: unknown;
+};
+
+const DEFAULT_CONFIG: AzureNetConfig = {
+	contexts: [],
+	defaultContext: 'web',
+	coreAlias: '$core'
+};
+
+function toObjectFromDefaultExport(content: string): Record<string, unknown> {
+	const source = String(content ?? '').trim();
+	if (!source.length) return {};
+
+	const replacedExport = source.replace(/^\s*export\s+default\s+/m, 'return ');
+	if (replacedExport === source) return {};
+
+	const withSemicolon = /;\s*$/.test(replacedExport) ? replacedExport : `${replacedExport};`;
+
+	try {
+		return new Function(withSemicolon)() ?? {};
+	} catch {
+		return {};
+	}
+}
+
+export function resolveConfigFile(cwd = process.cwd()): { exists: boolean; filepath: string; type: 'ts' | 'js' } {
+	const tsPath = path.join(cwd, 'azure-net.config.ts');
+	const jsPath = path.join(cwd, 'azure-net.config.js');
+
+	if (fsSync.existsSync(tsPath)) {
+		return { exists: true, filepath: tsPath, type: 'ts' };
+	}
+	if (fsSync.existsSync(jsPath)) {
+		return { exists: true, filepath: jsPath, type: 'js' };
+	}
+
+	return { exists: false, filepath: tsPath, type: 'ts' };
+}
+
+export async function loadUserConfig(): Promise<AzureNetConfig> {
+	const { exists, filepath } = resolveConfigFile();
+	if (!exists) {
+		return { ...DEFAULT_CONFIG };
+	}
+
+	try {
+		const content = await fs.readFile(filepath, 'utf-8');
+		const parsed = toObjectFromDefaultExport(content);
+		if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+			return { ...DEFAULT_CONFIG };
+		}
+
+		return { ...DEFAULT_CONFIG, ...(parsed as Record<string, unknown>) };
+	} catch {
+		return { ...DEFAULT_CONFIG };
+	}
+}

package/src/commands/generate/generateCrudBase.js

@@ -1,188 +0,0 @@
-import prompts from 'prompts';
-import path from 'path';
-import { selectContext, getContextPath, toPascalCase, toCamelCase, getAvailableFiles, toKebabCase } from '../../utils/contextUtils.js';
-import { writeIfNotExists, updateIndexTs, updateCoreIndex } from '../../utils/fileUtils.js';
-
-// Templates for CRUD base generation
-const entityTemplate = `export interface I{{name}} {
-\tid: number;
-\t// Add entity fields here
-\tcreated_at: string;
-\tupdated_at: string;
-}`;
-
-const portsIndexTemplate = `import type { I{{name}} } from '\${{context}}/domain/{{entityLower}}/model';
-
-export type I{{name}}Collection = I{{name}}[];
-
-export interface I{{name}}CollectionQuery {
-\tpage?: number;
-\tperPage?: number;
-\t[key: string]: unknown;
-}
-
-export interface I{{name}}CreateRequest {
-\t// Add request fields here
-\t[key: string]: unknown;
-}
-
-export interface I{{name}}UpdateRequest {
-\t// Add request fields here
-\t[key: string]: unknown;
-}`;
-
-const repositoryTemplate = `import { {{datasource}} } from '{{datasourceImport}}';
-import type { 
-\tI{{name}},
-\tI{{name}}Collection,
-\tI{{name}}CollectionQuery,
-\tI{{name}}CreateRequest,
-\tI{{name}}UpdateRequest
-} from '\${{context}}/domain/{{entityLower}}';
-
-export class {{name}}Repository {
-\tprivate endpoint = '{{endpoint}}';
-\t
-\tconstructor(private {{datasourceVar}}: {{datasource}}) {}
-\t
-\tpublic async collection(query?: I{{name}}CollectionQuery) {
-\t\treturn this.{{datasourceVar}}.createRequest<I{{name}}Collection>(({ http, query: q }) => 
-\t\t\thttp.get(\`\${this.endpoint}\${q.build(query ?? {})}\`)
-\t\t).then(res => res.getData());
-\t}
-\t
-\tpublic async resource(id: number) {
-\t\treturn this.{{datasourceVar}}.createRequest<I{{name}}>(({ http }) => 
-\t\t\thttp.get(\`\${this.endpoint}/\${id}\`)
-\t\t).then(res => res.getData());
-\t}
-\t
-\tpublic async create(data: I{{name}}CreateRequest) {
-\t\treturn this.{{datasourceVar}}.createRequest<I{{name}}>(({ http }) => 
-\t\t\thttp.post(this.endpoint, { json: data })
-\t\t).then(res => res.getData());
-\t}
-\t
-\tpublic async update(id: number, data: I{{name}}UpdateRequest) {
-\t\treturn this.{{datasourceVar}}.createRequest<I{{name}}>(({ http }) => 
-\t\t\thttp.put(\`\${this.endpoint}/\${id}\`, { json: data })
-\t\t).then(res => res.getData());
-\t}
-\t
-\tpublic async destroy(id: number) {
-\t\treturn this.{{datasourceVar}}.createRequest<void>(({ http }) => 
-\t\t\thttp.delete(\`\${this.endpoint}/\${id}\`)
-\t\t).then(() => undefined);
-\t}
-}`;
-
-const serviceTemplate = `import { ClassMirror } from '@azure-net/kit';
-import { {{name}}Repository } from '\${{context}}/infrastructure/http/repositories';
-
-export class {{name}}Service extends ClassMirror<{{name}}Repository> {
-\tconstructor(private {{camelName}}Repository: {{name}}Repository) {
-\t\tsuper({{camelName}}Repository);
-\t}
-\t
-\tdeclare collection: {{name}}Repository['collection'];
-\tdeclare resource: {{name}}Repository['resource'];
-\tdeclare create: {{name}}Repository['create'];
-\tdeclare update: {{name}}Repository['update'];
-\tdeclare destroy: {{name}}Repository['destroy'];
-}`;
-
-export default async function generateCrudBase() {
-	const context = await selectContext('Select context for CRUD base:');
-
-	const { name } = await prompts({
-		type: 'text',
-		name: 'name',
-		message: 'Entity name (PascalCase):'
-	});
-
-	const { endpoint } = await prompts({
-		type: 'text',
-		name: 'endpoint',
-		message: 'API endpoint (e.g. /api/users):'
-	});
-
-	// Get available datasources
-	const contextPath = getContextPath(context);
-	const coreDatasources = await getAvailableFiles(path.join(process.cwd(), 'src/core/datasources'));
-	const contextDatasources = await getAvailableFiles(path.join(contextPath, 'infrastructure/http/datasources'));
-
-	const allDatasources = [
-		...coreDatasources.map((d) => ({ title: `${d} (core)`, value: { name: d, from: 'core' } })),
-		...contextDatasources.map((d) => ({ title: `${d} (${context})`, value: { name: d, from: context } }))
-	];
-
-	const { datasource } = await prompts({
-		type: 'select',
-		name: 'datasource',
-		message: 'Select datasource:',
-		choices: allDatasources
-	});
-
-	const pascalName = toPascalCase(name);
-	const camelName = toCamelCase(name);
-	const entityLower = toKebabCase(pascalName);
-
-	console.log('\n🚀 Generating CRUD base (repository & service)...\n');
-
-	// 1. Create Domain structure
-	const domainPath = path.join(contextPath, 'domain', entityLower);
-	const modelPath = path.join(domainPath, 'model');
-	const portsPath = path.join(domainPath, 'ports');
-
-	// Create Model
-	await writeIfNotExists(path.join(modelPath, 'index.ts'), entityTemplate.replace(/{{name}}/g, pascalName));
-
-	// Create Ports
-	await writeIfNotExists(
-		path.join(portsPath, 'index.ts'),
-		portsIndexTemplate
-			.replace(/{{name}}/g, pascalName)
-			.replace(/{{context}}/g, context)
-			.replace(/{{entityLower}}/g, entityLower)
-	);
-
-	// 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 === 'core' ? '$core/datasources' : `\$${context}/infrastructure/http/datasources`;
-
-	await writeIfNotExists(
-		path.join(repoPath, `${pascalName}Repository.ts`),
-		repositoryTemplate
-			.replace(/{{name}}/g, pascalName)
-			.replace(/{{context}}/g, context)
-			.replace(/{{endpoint}}/g, endpoint)
-			.replace(/{{datasource}}/g, datasource.name)
-			.replace(/{{datasourceImport}}/g, datasourceImport)
-			.replace(/{{datasourceVar}}/g, toCamelCase(datasource.name))
-			.replace(/{{entityLower}}/g, entityLower)
-	);
-	await updateIndexTs(repoPath);
-
-	// 3. Create Service
-	const servicePath = path.join(contextPath, 'application/services');
-	await writeIfNotExists(
-		path.join(servicePath, `${pascalName}Service.ts`),
-		serviceTemplate
-			.replace(/{{name}}/g, pascalName)
-			.replace(/{{camelName}}/g, camelName)
-			.replace(/{{context}}/g, context)
-	);
-	await updateIndexTs(servicePath);
-
-	// 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`);
-	console.log(`   2. Add ${pascalName}Service to ApplicationProvider`);
-	console.log(`   3. Use 'make:crud-presenter' to create the CRUD presenter`);
-}

package/src/commands/generate/generateCrudPresenter.js

@@ -1,225 +0,0 @@
-import prompts from 'prompts';
-import path from 'path';
-import {
-	selectContext,
-	getContextPath,
-	toPascalCase,
-	getAvailableFiles,
-	getApplicationProviderServices,
-	toKebabCase
-} from '../../utils/contextUtils.js';
-import { updateIndexTs, writeIfNotExists, updateCoreIndex } from '../../utils/fileUtils.js';
-
-const createSchemaTemplate = `import { {{schemaFactory}} } from '{{schemaImport}}';
-import type { I{{name}}CreateRequest } from '\${{context}}/domain/{{entityLower}}';
-
-export const Create{{name}}Schema = {{schemaFactory}}<I{{name}}CreateRequest>()
-\t.rules(() => ({
-\t\t// Add validation rules here
-\t}))
-\t.create();`;
-
-const updateSchemaTemplate = `import { {{schemaFactory}} } from '{{schemaImport}}';
-import type { I{{name}}UpdateRequest } from '\${{context}}/domain/{{entityLower}}';
-
-export const Update{{name}}Schema = {{schemaFactory}}<I{{name}}UpdateRequest>()
-\t.rules(() => ({
-\t\t// Add validation rules here
-\t}))
-\t.create();`;
-
-const presenterWithCoreTemplate = `import { {{presenterFactory}} } from '$core/presenters';
-import { ApplicationProvider } from '\${{context}}/application';
-import { Create{{name}}Schema, Update{{name}}Schema } from './schema';
-import type { 
-\tI{{name}},
-\tI{{name}}CollectionQuery,
-\tI{{name}}CreateRequest,
-\tI{{name}}UpdateRequest
-} from '\${{context}}/domain/{{entityLower}}';
-
-export const {{name}}Presenter = {{presenterFactory}}('{{name}}Presenter', ({ createAsyncResource, createAsyncAction }) => {
-\tconst { {{serviceName}} } = ApplicationProvider();
-\t
-\tconst collection = async (query?: I{{name}}CollectionQuery) => 
-\t\tawait createAsyncResource({{serviceName}}.collection(query));
-\t
-\tconst resource = async (id: number) => 
-\t\tawait createAsyncResource({{serviceName}}.resource(id));
-\t
-\tconst create = async (request: I{{name}}CreateRequest) =>
-\t\tawait createAsyncAction<I{{name}}, I{{name}}CreateRequest>(() => {{serviceName}}.create(Create{{name}}Schema.from(request).json()));
-\t
-\tconst update = async (id: number, request: I{{name}}UpdateRequest) =>
-\t\tawait createAsyncAction<I{{name}}, I{{name}}UpdateRequest>(() => {{serviceName}}.update(id, Update{{name}}Schema.from(request).json()));
-\t
-\tconst destroy = async (id: number) => 
-\t\tawait createAsyncAction(() => {{serviceName}}.destroy(id));
-\t
-\treturn { collection, resource, create, update, destroy };
-});`;
-
-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/{{entityLower}}';
-
-export const {{name}}Presenter = createPresenter('{{name}}Presenter', () => {
-\tconst { {{serviceName}} } = ApplicationProvider();
-\t
-\tconst collection = async (query?: I{{name}}CollectionQuery) => 
-\t\tawait {{serviceName}}.collection(query);
-\t
-\tconst resource = async (id: number) => 
-\t\tawait {{serviceName}}.resource(id);
-\t
-\tconst create = async (request: I{{name}}CreateRequest) =>
-\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
-\tconst destroy = async (id: number) => 
-\t\tawait {{serviceName}}.destroy(id);
-\t
-\treturn { collection, resource, create, update, destroy };
-});`;
-
-export default async function generateCrudPresenter() {
-	const context = await selectContext('Select context for CRUD presenter:');
-
-	// 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 for CRUD:',
-		choices: services.map((s) => ({ title: s, value: s }))
-	});
-
-	// Extract entity name from service name
-	const entityName = service.replace('Service', '');
-	const pascalName = toPascalCase(entityName);
-	const entityLower = toKebabCase(pascalName);
-
-	// Get schema factory
-	const coreSchemas = await getAvailableFiles(path.join(process.cwd(), 'src/core/schemas'));
-
-	const { schemaType } = await prompts({
-		type: 'select',
-		name: 'schemaType',
-		message: 'Select schema factory:',
-		choices: [
-			{ title: 'Use createSchemaFactory from package', value: 'package' },
-			...coreSchemas.map((s) => ({ title: `Use ${s} from core`, value: s }))
-		]
-	});
-
-	// Get presenter factory
-	const corePresenters = await getAvailableFiles(path.join(process.cwd(), 'src/core/presenters'));
-
-	const { presenterType } = await prompts({
-		type: 'select',
-		name: 'presenterType',
-		message: 'Select presenter factory:',
-		choices: [
-			{ title: 'Use createPresenter from package', value: 'package' },
-			...corePresenters.map((p) => ({ title: `Use ${p} from core`, value: p }))
-		]
-	});
-
-	const contextPath = getContextPath(context);
-	const deliveryModulePath = path.join(contextPath, 'delivery', entityLower);
-	const schemaPath = path.join(deliveryModulePath, 'schema');
-
-	console.log('\n🚀 Generating CRUD presenter...\n');
-
-	// Create schemas
-	const schemaFactory = schemaType === 'package' ? 'Schema' : schemaType;
-	const schemaImport = schemaType === 'package' ? '@azure-net/kit' : '$core/schemas';
-
-	if (schemaType === 'package') {
-		const schemaImportFull = `import { createSchemaFactory } from '@azure-net/kit';
-import { createRules, validationMessagesI18n } from '@azure-net/kit/schema';
-
-const Schema = createSchemaFactory(createRules(validationMessagesI18n));`;
-
-		await writeIfNotExists(
-			path.join(schemaPath, `Create${pascalName}Schema.ts`),
-			schemaImportFull +
-				'\n' +
-				createSchemaTemplate
-					.replace("import { {{schemaFactory}} } from '{{schemaImport}}';\n", '')
-					.replace(/{{name}}/g, pascalName)
-					.replace(/{{context}}/g, context)
-					.replace(/{{entityLower}}/g, entityLower)
-					.replace(/{{schemaFactory}}/g, 'Schema')
-		);
-
-		await writeIfNotExists(
-			path.join(schemaPath, `Update${pascalName}Schema.ts`),
-			schemaImportFull +
-				'\n' +
-				updateSchemaTemplate
-					.replace("import { {{schemaFactory}} } from '{{schemaImport}}';\n", '')
-					.replace(/{{name}}/g, pascalName)
-					.replace(/{{context}}/g, context)
-					.replace(/{{entityLower}}/g, entityLower)
-					.replace(/{{schemaFactory}}/g, 'Schema')
-		);
-	} else {
-		await writeIfNotExists(
-			path.join(schemaPath, `Create${pascalName}Schema.ts`),
-			createSchemaTemplate
-				.replace(/{{name}}/g, pascalName)
-				.replace(/{{context}}/g, context)
-				.replace(/{{entityLower}}/g, entityLower)
-				.replace(/{{schemaFactory}}/g, schemaFactory)
-				.replace(/{{schemaImport}}/g, schemaImport)
-		);
-
-		await writeIfNotExists(
-			path.join(schemaPath, `Update${pascalName}Schema.ts`),
-			updateSchemaTemplate
-				.replace(/{{name}}/g, pascalName)
-				.replace(/{{context}}/g, context)
-				.replace(/{{entityLower}}/g, entityLower)
-				.replace(/{{schemaFactory}}/g, schemaFactory)
-				.replace(/{{schemaImport}}/g, schemaImport)
-		);
-	}
-	await updateIndexTs(schemaPath);
-
-	// Create Presenter
-	const presenterTemplate = presenterType === 'package' ? presenterWithoutCoreTemplate : presenterWithCoreTemplate;
-
-	const presenterFactory = presenterType === 'package' ? 'createPresenter' : presenterType;
-
-	await writeIfNotExists(
-		path.join(deliveryModulePath, `${pascalName}Presenter.ts`),
-		presenterTemplate
-			.replace(/{{name}}/g, pascalName)
-			.replace(/{{context}}/g, context)
-			.replace(/{{serviceName}}/g, service)
-			.replace(/{{presenterFactory}}/g, presenterFactory)
-			.replace(/{{entityLower}}/g, entityLower)
-	);
-
-	// Create module index
-	await writeIfNotExists(path.join(deliveryModulePath, 'index.ts'), `export * from './${pascalName}Presenter';\nexport * from './schema';`);
-
-	// Update core index
-	await updateCoreIndex();
-
-	console.log(`✅ CRUD presenter for ${pascalName} created successfully!`);
-}