@azure-net/cli 5.0.1 → 5.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (8) hide show
  1. package/bin/azure-net.js +7 -0
  2. package/bin/azure-net.ts +8 -0
  3. package/package.json +9 -2
  4. package/src/generate/module/generatePresenter.js +348 -360
  5. package/src/generate/routes/generateRoutes.js +217 -0
  6. package/src/generate/routes/generateRoutes.ts +282 -0
  7. package/src/scaffolds/createPresenterFactory.js +63 -65
  8. package/src/utils/loadConfig.ts +1 -0
package/src/generate/module/generatePresenter.js CHANGED
@@ -8,395 +8,383 @@ import { loadUserConfig } from '../../utils/loadConfig.js';
8
8
  import { getFoundationConstructImportPath, getFoundationConstructPath, getSharedState } from '../../utils/sharedFoundation.js';
9
9
  const PRIMITIVE_TYPES = new Set(['string', 'number', 'boolean', 'unknown', 'void', 'null', 'undefined', 'bigint', 'symbol', 'never']);
10
10
  const parseProviderInfo = (content) => {
11
- const providerNameMatch = content.match(/export\s+const\s+(\w+)\s*=\s*createBoundaryProvider/);
12
- const providerName = providerNameMatch?.[1] ?? 'ApplicationProvider';
13
- const registerMatch = content.match(/register\s*:\s*\([^)]*\)\s*=>\s*\(\{([\s\S]*?)\}\)/m);
14
- const registerBody = registerMatch?.[1] ?? '';
15
- const keys = [];
16
- const keyRegex = /([A-Za-z_]\w*)\s*:/g;
17
- let keyMatch;
18
- while ((keyMatch = keyRegex.exec(registerBody)) !== null) {
19
- const key = keyMatch[1];
20
- if (key)
21
- keys.push(key);
22
- }
23
- return { providerName, registeredKeys: keys };
11
+ const providerNameMatch = content.match(/export\s+const\s+(\w+)\s*=\s*createBoundaryProvider/);
12
+ const providerName = providerNameMatch?.[1] ?? 'ApplicationProvider';
13
+ const registerMatch = content.match(/register\s*:\s*\([^)]*\)\s*=>\s*\(\{([\s\S]*?)\}\)/m);
14
+ const registerBody = registerMatch?.[1] ?? '';
15
+ const keys = [];
16
+ const keyRegex = /([A-Za-z_]\w*)\s*:/g;
17
+ let keyMatch;
18
+ while ((keyMatch = keyRegex.exec(registerBody)) !== null) {
19
+ const key = keyMatch[1];
20
+ if (key) keys.push(key);
21
+ }
22
+ return { providerName, registeredKeys: keys };
24
23
  };
25
24
  const parseUseCasesInfo = (content) => {
26
- const interfaceImport = content.match(/import\s+type\s+\{\s*(\w+)\s*\}\s+from\s+['"]([^'"]+)['"]/);
27
- const repositoryInterfaceName = interfaceImport?.[1] ?? null;
28
- const domainImportPath = interfaceImport?.[2] ?? null;
29
- const domainNameMatch = domainImportPath?.match(/\/layers\/domain\/([^'"]+)$/);
30
- const domainName = domainNameMatch?.[1] ?? null;
31
- const methods = [];
32
- const declareRegex = /declare\s+(\w+)\s*:\s*\w+\['\w+'\];/g;
33
- let declareMatch;
34
- while ((declareMatch = declareRegex.exec(content)) !== null) {
35
- const methodName = declareMatch[1];
36
- if (methodName)
37
- methods.push(methodName);
38
- }
39
- return { repositoryInterfaceName, domainName, methods };
25
+ const interfaceImport = content.match(/import\s+type\s+\{\s*(\w+)\s*\}\s+from\s+['"]([^'"]+)['"]/);
26
+ const repositoryInterfaceName = interfaceImport?.[1] ?? null;
27
+ const domainImportPath = interfaceImport?.[2] ?? null;
28
+ const domainNameMatch = domainImportPath?.match(/\/layers\/domain\/([^'"]+)$/);
29
+ const domainName = domainNameMatch?.[1] ?? null;
30
+ const methods = [];
31
+ const declareRegex = /declare\s+(\w+)\s*:\s*\w+\['\w+'\];/g;
32
+ let declareMatch;
33
+ while ((declareMatch = declareRegex.exec(content)) !== null) {
34
+ const methodName = declareMatch[1];
35
+ if (methodName) methods.push(methodName);
36
+ }
37
+ return { repositoryInterfaceName, domainName, methods };
40
38
  };
41
39
  const parseRepositoryInterfaceMethods = (content) => {
42
- const methods = [];
43
- const regex = /(\w+)\(([^)]*)\)\s*:\s*Promise<([^>]+)>;/g;
44
- let match;
45
- while ((match = regex.exec(content)) !== null) {
46
- const methodName = match[1];
47
- const paramsChunk = match[2];
48
- const responseTypeChunk = match[3];
49
- if (!methodName || paramsChunk === undefined || !responseTypeChunk)
50
- continue;
51
- const paramsRaw = paramsChunk.trim();
52
- const params = paramsRaw
53
- ? paramsRaw.split(',').map((part) => {
54
- const [name, ...typeParts] = part.trim().split(':');
55
- return { name: String(name ?? '').trim(), type: typeParts.join(':').trim() };
56
- })
57
- : [];
58
- methods.push({
59
- name: methodName,
60
- params,
61
- responseType: responseTypeChunk.trim()
62
- });
63
- }
64
- return methods;
40
+ const methods = [];
41
+ const regex = /(\w+)\(([^)]*)\)\s*:\s*Promise<([^>]+)>;/g;
42
+ let match;
43
+ while ((match = regex.exec(content)) !== null) {
44
+ const methodName = match[1];
45
+ const paramsChunk = match[2];
46
+ const responseTypeChunk = match[3];
47
+ if (!methodName || paramsChunk === undefined || !responseTypeChunk) continue;
48
+ const paramsRaw = paramsChunk.trim();
49
+ const params = paramsRaw
50
+ ? paramsRaw.split(',').map((part) => {
51
+ const [name, ...typeParts] = part.trim().split(':');
52
+ return { name: String(name ?? '').trim(), type: typeParts.join(':').trim() };
53
+ })
54
+ : [];
55
+ methods.push({
56
+ name: methodName,
57
+ params,
58
+ responseType: responseTypeChunk.trim()
59
+ });
60
+ }
61
+ return methods;
65
62
  };
66
63
  const findRepositoryByInterface = async (contextName, repositoryInterfaceName) => {
67
- const repositoriesPath = path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'infrastructure', 'http', 'repositories');
68
- try {
69
- const files = await fs.readdir(repositoriesPath);
70
- for (const fileName of files) {
71
- if (!fileName.endsWith('.ts') || fileName === 'index.ts')
72
- continue;
73
- const absolute = path.join(repositoriesPath, fileName);
74
- const content = await fs.readFile(absolute, 'utf-8');
75
- if (content.includes(`implements ${repositoryInterfaceName}`)) {
76
- return { filePath: absolute, content };
77
- }
78
- }
79
- return null;
80
- }
81
- catch {
82
- return null;
83
- }
64
+ const repositoriesPath = path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'infrastructure', 'http', 'repositories');
65
+ try {
66
+ const files = await fs.readdir(repositoriesPath);
67
+ for (const fileName of files) {
68
+ if (!fileName.endsWith('.ts') || fileName === 'index.ts') continue;
69
+ const absolute = path.join(repositoriesPath, fileName);
70
+ const content = await fs.readFile(absolute, 'utf-8');
71
+ if (content.includes(`implements ${repositoryInterfaceName}`)) {
72
+ return { filePath: absolute, content };
73
+ }
74
+ }
75
+ return null;
76
+ } catch {
77
+ return null;
78
+ }
84
79
  };
85
80
  const parseRepositoryHttpMethods = (content) => {
86
- const methods = new Map();
87
- const regex = /public\s+async\s+(\w+)\([^)]*\)\s*\{([\s\S]*?)\n\t\}/g;
88
- let match;
89
- while ((match = regex.exec(content)) !== null) {
90
- const methodName = match[1];
91
- if (!methodName)
92
- continue;
93
- const body = match[2] ?? '';
94
- const httpMatch = body.match(/http\.(get|post|put|delete|head|options|patch)\(/);
95
- if (httpMatch?.[1])
96
- methods.set(methodName, httpMatch[1]);
97
- }
98
- return methods;
81
+ const methods = new Map();
82
+ const regex = /public\s+async\s+(\w+)\([^)]*\)\s*\{([\s\S]*?)\n\t\}/g;
83
+ let match;
84
+ while ((match = regex.exec(content)) !== null) {
85
+ const methodName = match[1];
86
+ if (!methodName) continue;
87
+ const body = match[2] ?? '';
88
+ const httpMatch = body.match(/http\.(get|post|put|delete|head|options|patch)\(/);
89
+ if (httpMatch?.[1]) methods.set(methodName, httpMatch[1]);
90
+ }
91
+ return methods;
99
92
  };
100
93
  const getSharedPresenterFactories = async () => {
101
- const { sharedContext } = await getSharedState();
102
- const presenterPath = getFoundationConstructPath(sharedContext.name, 'presenter');
103
- try {
104
- const files = await fs.readdir(presenterPath);
105
- return files.filter((item) => item.endsWith('.ts') && item !== 'index.ts').map((item) => item.replace(/\.ts$/, ''));
106
- }
107
- catch {
108
- return [];
109
- }
94
+ const { sharedContext } = await getSharedState();
95
+ const presenterPath = getFoundationConstructPath(sharedContext.name, 'presenter');
96
+ try {
97
+ const files = await fs.readdir(presenterPath);
98
+ return files.filter((item) => item.endsWith('.ts') && item !== 'index.ts').map((item) => item.replace(/\.ts$/, ''));
99
+ } catch {
100
+ return [];
101
+ }
110
102
  };
111
103
  const getSharedSchemaFactories = async () => {
112
- const { sharedContext } = await getSharedState();
113
- const schemaPath = getFoundationConstructPath(sharedContext.name, 'schema');
114
- try {
115
- const files = await fs.readdir(schemaPath);
116
- return files.filter((item) => item.endsWith('.ts') && item !== 'index.ts').map((item) => item.replace(/\.ts$/, ''));
117
- }
118
- catch {
119
- return [];
120
- }
104
+ const { sharedContext } = await getSharedState();
105
+ const schemaPath = getFoundationConstructPath(sharedContext.name, 'schema');
106
+ try {
107
+ const files = await fs.readdir(schemaPath);
108
+ return files.filter((item) => item.endsWith('.ts') && item !== 'index.ts').map((item) => item.replace(/\.ts$/, ''));
109
+ } catch {
110
+ return [];
111
+ }
121
112
  };
122
113
  const normalizePresenterName = (rawName, fallbackUseCasesName) => {
123
- const fallback = fallbackUseCasesName.replace(/UseCases$/, '') || 'Module';
124
- const source = String(rawName ?? '').trim() || fallback;
125
- const normalized = toPascalCase(source);
126
- return normalized.endsWith('Presenter') ? normalized : `${normalized}Presenter`;
114
+ const fallback = fallbackUseCasesName.replace(/UseCases$/, '') || 'Module';
115
+ const source = String(rawName ?? '').trim() || fallback;
116
+ const normalized = toPascalCase(source);
117
+ return normalized.endsWith('Presenter') ? normalized : `${normalized}Presenter`;
127
118
  };
128
119
  const isPrimitive = (typeName) => PRIMITIVE_TYPES.has(String(typeName ?? '').trim());
129
120
  const normalizeTypeImports = (types) => Array.from(new Set(types.filter((typeName) => !isPrimitive(typeName))));
130
121
  const isPathParamName = (name) => name === 'pathParam' || name === 'path';
131
122
  const toTypeFileName = (typeName) => String(typeName ?? '').replace(/^I/, '') || 'Type';
132
123
  const buildMethodInvocation = (method, useCasesName, schemaByMethod) => {
133
- const paramsSignature = method.params.map((item) => `${item.name}: ${item.type}`).join(', ');
134
- const argNames = method.params.map((item) => item.name);
135
- const requestParam = method.params.find((item) => !isPathParamName(item.name));
136
- const schemaInfo = schemaByMethod.get(method.name) ?? null;
137
- const args = argNames.map((argName) => {
138
- if (schemaInfo && requestParam && argName === requestParam.name) {
139
- return `${schemaInfo.constName}.from(${argName}).json()`;
140
- }
141
- return argName;
142
- });
143
- const httpMethod = method.httpMethod;
144
- if (httpMethod === 'get' || httpMethod === 'head' || httpMethod === 'options') {
145
- return `\tconst ${method.name} = (${paramsSignature}) => createAsyncResource(() => ${useCasesName}.${method.name}(${args.join(', ')}));`;
146
- }
147
- const responseType = method.responseType;
148
- const requestType = requestParam?.type ?? null;
149
- let generic = `<${responseType}`;
150
- if (requestType)
151
- generic += `, ${requestType}`;
152
- generic += '>';
153
- return `\tconst ${method.name} = async (${paramsSignature}) =>\n\t\tawait createAsyncAction${generic}(() => ${useCasesName}.${method.name}(${args.join(', ')}));`;
124
+ const paramsSignature = method.params.map((item) => `${item.name}: ${item.type}`).join(', ');
125
+ const argNames = method.params.map((item) => item.name);
126
+ const requestParam = method.params.find((item) => !isPathParamName(item.name));
127
+ const schemaInfo = schemaByMethod.get(method.name) ?? null;
128
+ const args = argNames.map((argName) => {
129
+ if (schemaInfo && requestParam && argName === requestParam.name) {
130
+ return `${schemaInfo.constName}.from(${argName}).json()`;
131
+ }
132
+ return argName;
133
+ });
134
+ const httpMethod = method.httpMethod;
135
+ if (httpMethod === 'get' || httpMethod === 'head' || httpMethod === 'options') {
136
+ return `\tconst ${method.name} = (${paramsSignature}) => createAsyncResource(() => ${useCasesName}.${method.name}(${args.join(', ')}));`;
137
+ }
138
+ const responseType = method.responseType;
139
+ const requestType = requestParam?.type ?? null;
140
+ let generic = `<${responseType}`;
141
+ if (requestType) generic += `, ${requestType}`;
142
+ generic += '>';
143
+ return `\tconst ${method.name} = async (${paramsSignature}) =>\n\t\tawait createAsyncAction${generic}(() => ${useCasesName}.${method.name}(${args.join(', ')}));`;
154
144
  };
155
145
  const getApplicationProviderFile = async (contextName) => {
156
- const providersPath = path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'application', 'providers');
157
- const targetPath = path.join(providersPath, 'ApplicationProvider.ts');
158
- try {
159
- await fs.access(targetPath);
160
- return targetPath;
161
- }
162
- catch {
163
- const files = await fs.readdir(providersPath);
164
- const candidate = files.find((item) => item.endsWith('.ts') && item !== 'index.ts');
165
- return candidate ? path.join(providersPath, candidate) : null;
166
- }
146
+ const providersPath = path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'application', 'providers');
147
+ const targetPath = path.join(providersPath, 'ApplicationProvider.ts');
148
+ try {
149
+ await fs.access(targetPath);
150
+ return targetPath;
151
+ } catch {
152
+ const files = await fs.readdir(providersPath);
153
+ const candidate = files.find((item) => item.endsWith('.ts') && item !== 'index.ts');
154
+ return candidate ? path.join(providersPath, candidate) : null;
155
+ }
167
156
  };
168
157
  const resolveDomainInterfaceFile = async ({ contextName, domainName, interfaceName }) => {
169
- const portsPath = path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'domain', domainName, 'ports');
170
- const preferredPath = path.join(portsPath, `${toTypeFileName(interfaceName)}.ts`);
171
- const legacyPath = path.join(portsPath, `${interfaceName}.ts`);
172
- for (const candidate of [preferredPath, legacyPath]) {
173
- try {
174
- await fs.access(candidate);
175
- return candidate;
176
- }
177
- catch {
178
- // Try the next candidate.
179
- }
180
- }
181
- try {
182
- const files = await fs.readdir(portsPath);
183
- for (const fileName of files) {
184
- if (!fileName.endsWith('.ts') || fileName === 'index.ts')
185
- continue;
186
- const candidate = path.join(portsPath, fileName);
187
- const content = await fs.readFile(candidate, 'utf-8');
188
- const escapedName = interfaceName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
189
- if (new RegExp(`export\\s+interface\\s+${escapedName}\\b`).test(content)) {
190
- return candidate;
191
- }
192
- }
193
- }
194
- catch {
195
- return null;
196
- }
197
- return null;
158
+ const portsPath = path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'domain', domainName, 'ports');
159
+ const preferredPath = path.join(portsPath, `${toTypeFileName(interfaceName)}.ts`);
160
+ const legacyPath = path.join(portsPath, `${interfaceName}.ts`);
161
+ for (const candidate of [preferredPath, legacyPath]) {
162
+ try {
163
+ await fs.access(candidate);
164
+ return candidate;
165
+ } catch {
166
+ // Try the next candidate.
167
+ }
168
+ }
169
+ try {
170
+ const files = await fs.readdir(portsPath);
171
+ for (const fileName of files) {
172
+ if (!fileName.endsWith('.ts') || fileName === 'index.ts') continue;
173
+ const candidate = path.join(portsPath, fileName);
174
+ const content = await fs.readFile(candidate, 'utf-8');
175
+ const escapedName = interfaceName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
176
+ if (new RegExp(`export\\s+interface\\s+${escapedName}\\b`).test(content)) {
177
+ return candidate;
178
+ }
179
+ }
180
+ } catch {
181
+ return null;
182
+ }
183
+ return null;
198
184
  };
199
185
  export default async function generatePresenter(options = {}) {
200
- let contextName = options.contextName ? String(options.contextName) : null;
201
- if (!contextName) {
202
- contextName = await selectContext('Select context for presenter:');
203
- }
204
- if (!contextName) {
205
- process.exitCode = 1;
206
- return;
207
- }
208
- const appProviderFile = await getApplicationProviderFile(contextName);
209
- if (!appProviderFile) {
210
- console.error('❌ ApplicationProvider file was not found.');
211
- process.exitCode = 1;
212
- return;
213
- }
214
- const appProviderContent = await fs.readFile(appProviderFile, 'utf-8');
215
- const providerInfo = parseProviderInfo(appProviderContent);
216
- const useCasesPath = path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'application', 'use-cases');
217
- let useCasesFiles = [];
218
- try {
219
- useCasesFiles = (await fs.readdir(useCasesPath))
220
- .filter((item) => item.endsWith('.ts') && item !== 'index.ts')
221
- .map((item) => item.replace(/\.ts$/, ''));
222
- }
223
- catch {
224
- // ignore
225
- }
226
- const registeredUseCases = useCasesFiles.filter((item) => providerInfo.registeredKeys.includes(item));
227
- if (!registeredUseCases.length) {
228
- console.error('❌ No registered UseCases were found in ApplicationProvider register().');
229
- process.exitCode = 1;
230
- return;
231
- }
232
- let useCasesName = options.useCasesName ? String(options.useCasesName) : '';
233
- if (!useCasesName) {
234
- const { selectedUseCases } = await prompts({
235
- type: 'select',
236
- name: 'selectedUseCases',
237
- message: 'Select UseCases:',
238
- choices: registeredUseCases.map((item) => ({ title: item, value: item })),
239
- initial: 0
240
- });
241
- useCasesName = String(selectedUseCases ?? '');
242
- }
243
- if (!registeredUseCases.includes(useCasesName)) {
244
- console.error(`❌ UseCases "${useCasesName}" is not registered in ApplicationProvider.`);
245
- process.exitCode = 1;
246
- return;
247
- }
248
- const useCasesFile = path.join(useCasesPath, `${useCasesName}.ts`);
249
- const useCasesContent = await fs.readFile(useCasesFile, 'utf-8');
250
- const useCasesInfo = parseUseCasesInfo(useCasesContent);
251
- if (!useCasesInfo.repositoryInterfaceName || !useCasesInfo.domainName) {
252
- console.error('❌ Unable to parse repository interface import from UseCases.');
253
- process.exitCode = 1;
254
- return;
255
- }
256
- const repositoryInfo = await findRepositoryByInterface(contextName, useCasesInfo.repositoryInterfaceName);
257
- if (!repositoryInfo) {
258
- console.error(`❌ Repository implementing ${useCasesInfo.repositoryInterfaceName} was not found.`);
259
- process.exitCode = 1;
260
- return;
261
- }
262
- const repositoryHttpMethods = parseRepositoryHttpMethods(repositoryInfo.content);
263
- const domainPortsInterfacePath = await resolveDomainInterfaceFile({
264
- contextName,
265
- domainName: useCasesInfo.domainName,
266
- interfaceName: useCasesInfo.repositoryInterfaceName
267
- });
268
- if (!domainPortsInterfacePath) {
269
- console.error(`❌ Repository interface "${useCasesInfo.repositoryInterfaceName}" was not found in ${path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'domain', useCasesInfo.domainName, 'ports')}`);
270
- process.exitCode = 1;
271
- return;
272
- }
273
- const repositoryInterfaceContent = await fs.readFile(domainPortsInterfacePath, 'utf-8');
274
- const repositoryMethods = parseRepositoryInterfaceMethods(repositoryInterfaceContent).filter((method) => useCasesInfo.methods.includes(method.name));
275
- const { presenterNameRaw } = await prompts({
276
- type: 'text',
277
- name: 'presenterNameRaw',
278
- message: 'Presenter name (optional):'
279
- });
280
- const presenterName = normalizePresenterName(presenterNameRaw, useCasesName);
281
- const presenterFolder = toKebabCase(presenterName.replace(/Presenter$/, ''));
282
- const presentationPath = path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'presentation', presenterFolder);
283
- await fs.mkdir(presentationPath, { recursive: true });
284
- const { contexts, sharedAlias } = await getConfigState();
285
- const contextAlias = resolveContextAlias(contexts, contextName);
286
- const presenterImportPath = getFoundationConstructImportPath(sharedAlias, 'presenter');
287
- const schemaFactoryImportPath = getFoundationConstructImportPath(sharedAlias, 'schema');
288
- let presenterFactory = String((await loadUserConfig()).defaultPresenterFactory ?? '').trim();
289
- let useNativePresenter = false;
290
- if (!presenterFactory) {
291
- const availableFactories = await getSharedPresenterFactories();
292
- const { selectedFactory } = await prompts({
293
- type: 'select',
294
- name: 'selectedFactory',
295
- message: 'Select presenter factory:',
296
- choices: [
297
- ...availableFactories.map((item) => ({ title: item, value: item })),
298
- { title: 'Native createPresenter', value: '__native__' }
299
- ],
300
- initial: 0
301
- });
302
- if (selectedFactory === '__native__') {
303
- useNativePresenter = true;
304
- presenterFactory = 'createPresenter';
305
- }
306
- else {
307
- presenterFactory = String(selectedFactory ?? '');
308
- }
309
- }
310
- if (!presenterFactory) {
311
- useNativePresenter = true;
312
- presenterFactory = 'createPresenter';
313
- }
314
- const mutationMethods = repositoryMethods.filter((method) => {
315
- const httpMethod = repositoryHttpMethods.get(method.name) ?? 'get';
316
- return httpMethod !== 'get' && httpMethod !== 'head' && httpMethod !== 'options';
317
- });
318
- let schemaFactory = String((await loadUserConfig()).defaultSchemaFactory ?? '').trim();
319
- let schemaFactoryResolved = false;
320
- const schemaByMethod = new Map();
321
- const schemaImports = [];
322
- let schemaIndexNeeded = false;
323
- if (mutationMethods.length) {
324
- for (const method of mutationMethods) {
325
- const requestParam = method.params.find((item) => !isPathParamName(item.name));
326
- if (!requestParam)
327
- continue;
328
- const { shouldCreateSchema } = await prompts({
329
- type: 'confirm',
330
- name: 'shouldCreateSchema',
331
- message: `Create schema for "${method.name}"?`,
332
- initial: false
333
- });
334
- if (!shouldCreateSchema)
335
- continue;
336
- if (!schemaFactoryResolved) {
337
- if (!schemaFactory) {
338
- const availableSchemas = await getSharedSchemaFactories();
339
- if (!availableSchemas.length) {
340
- console.error('❌ No schema factories found in shared foundation constructs/schema.');
341
- process.exitCode = 1;
342
- return;
343
- }
344
- const { selectedSchemaFactory } = await prompts({
345
- type: 'select',
346
- name: 'selectedSchemaFactory',
347
- message: 'Select schema factory:',
348
- choices: availableSchemas.map((item) => ({ title: item, value: item })),
349
- initial: 0
350
- });
351
- schemaFactory = String(selectedSchemaFactory ?? '');
352
- }
353
- schemaFactoryResolved = true;
354
- }
355
- const schemaConstName = `${toPascalCase(method.name)}${presenterName}Schema`;
356
- const schemaFileName = `${schemaConstName}.ts`;
357
- const schemaPath = path.join(presentationPath, 'schema');
358
- await fs.mkdir(schemaPath, { recursive: true });
359
- schemaIndexNeeded = true;
360
- const schemaContent = `import { ${schemaFactory} } from '${schemaFactoryImportPath}';
186
+ let contextName = options.contextName ? String(options.contextName) : null;
187
+ if (!contextName) {
188
+ contextName = await selectContext('Select context for presenter:');
189
+ }
190
+ if (!contextName) {
191
+ process.exitCode = 1;
192
+ return;
193
+ }
194
+ const appProviderFile = await getApplicationProviderFile(contextName);
195
+ if (!appProviderFile) {
196
+ console.error('❌ ApplicationProvider file was not found.');
197
+ process.exitCode = 1;
198
+ return;
199
+ }
200
+ const appProviderContent = await fs.readFile(appProviderFile, 'utf-8');
201
+ const providerInfo = parseProviderInfo(appProviderContent);
202
+ const useCasesPath = path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'application', 'use-cases');
203
+ let useCasesFiles = [];
204
+ try {
205
+ useCasesFiles = (await fs.readdir(useCasesPath))
206
+ .filter((item) => item.endsWith('.ts') && item !== 'index.ts')
207
+ .map((item) => item.replace(/\.ts$/, ''));
208
+ } catch {
209
+ // ignore
210
+ }
211
+ const registeredUseCases = useCasesFiles.filter((item) => providerInfo.registeredKeys.includes(item));
212
+ if (!registeredUseCases.length) {
213
+ console.error('❌ No registered UseCases were found in ApplicationProvider register().');
214
+ process.exitCode = 1;
215
+ return;
216
+ }
217
+ let useCasesName = options.useCasesName ? String(options.useCasesName) : '';
218
+ if (!useCasesName) {
219
+ const { selectedUseCases } = await prompts({
220
+ type: 'select',
221
+ name: 'selectedUseCases',
222
+ message: 'Select UseCases:',
223
+ choices: registeredUseCases.map((item) => ({ title: item, value: item })),
224
+ initial: 0
225
+ });
226
+ useCasesName = String(selectedUseCases ?? '');
227
+ }
228
+ if (!registeredUseCases.includes(useCasesName)) {
229
+ console.error(`❌ UseCases "${useCasesName}" is not registered in ApplicationProvider.`);
230
+ process.exitCode = 1;
231
+ return;
232
+ }
233
+ const useCasesFile = path.join(useCasesPath, `${useCasesName}.ts`);
234
+ const useCasesContent = await fs.readFile(useCasesFile, 'utf-8');
235
+ const useCasesInfo = parseUseCasesInfo(useCasesContent);
236
+ if (!useCasesInfo.repositoryInterfaceName || !useCasesInfo.domainName) {
237
+ console.error('❌ Unable to parse repository interface import from UseCases.');
238
+ process.exitCode = 1;
239
+ return;
240
+ }
241
+ const repositoryInfo = await findRepositoryByInterface(contextName, useCasesInfo.repositoryInterfaceName);
242
+ if (!repositoryInfo) {
243
+ console.error(`❌ Repository implementing ${useCasesInfo.repositoryInterfaceName} was not found.`);
244
+ process.exitCode = 1;
245
+ return;
246
+ }
247
+ const repositoryHttpMethods = parseRepositoryHttpMethods(repositoryInfo.content);
248
+ const domainPortsInterfacePath = await resolveDomainInterfaceFile({
249
+ contextName,
250
+ domainName: useCasesInfo.domainName,
251
+ interfaceName: useCasesInfo.repositoryInterfaceName
252
+ });
253
+ if (!domainPortsInterfacePath) {
254
+ console.error(
255
+ `❌ Repository interface "${useCasesInfo.repositoryInterfaceName}" was not found in ${path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'domain', useCasesInfo.domainName, 'ports')}`
256
+ );
257
+ process.exitCode = 1;
258
+ return;
259
+ }
260
+ const repositoryInterfaceContent = await fs.readFile(domainPortsInterfacePath, 'utf-8');
261
+ const repositoryMethods = parseRepositoryInterfaceMethods(repositoryInterfaceContent).filter((method) =>
262
+ useCasesInfo.methods.includes(method.name)
263
+ );
264
+ const { presenterNameRaw } = await prompts({
265
+ type: 'text',
266
+ name: 'presenterNameRaw',
267
+ message: 'Presenter name (optional):'
268
+ });
269
+ const presenterName = normalizePresenterName(presenterNameRaw, useCasesName);
270
+ const presenterFolder = toKebabCase(presenterName.replace(/Presenter$/, ''));
271
+ const presentationPath = path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'presentation', presenterFolder);
272
+ await fs.mkdir(presentationPath, { recursive: true });
273
+ const { contexts, sharedAlias } = await getConfigState();
274
+ const contextAlias = resolveContextAlias(contexts, contextName);
275
+ const presenterImportPath = getFoundationConstructImportPath(sharedAlias, 'presenter');
276
+ const schemaFactoryImportPath = getFoundationConstructImportPath(sharedAlias, 'schema');
277
+ let presenterFactory = String((await loadUserConfig()).defaultPresenterFactory ?? '').trim();
278
+ let useNativePresenter = false;
279
+ if (!presenterFactory) {
280
+ const availableFactories = await getSharedPresenterFactories();
281
+ const { selectedFactory } = await prompts({
282
+ type: 'select',
283
+ name: 'selectedFactory',
284
+ message: 'Select presenter factory:',
285
+ choices: [
286
+ ...availableFactories.map((item) => ({ title: item, value: item })),
287
+ { title: 'Native createPresenter', value: '__native__' }
288
+ ],
289
+ initial: 0
290
+ });
291
+ if (selectedFactory === '__native__') {
292
+ useNativePresenter = true;
293
+ presenterFactory = 'createPresenter';
294
+ } else {
295
+ presenterFactory = String(selectedFactory ?? '');
296
+ }
297
+ }
298
+ if (!presenterFactory) {
299
+ useNativePresenter = true;
300
+ presenterFactory = 'createPresenter';
301
+ }
302
+ const mutationMethods = repositoryMethods.filter((method) => {
303
+ const httpMethod = repositoryHttpMethods.get(method.name) ?? 'get';
304
+ return httpMethod !== 'get' && httpMethod !== 'head' && httpMethod !== 'options';
305
+ });
306
+ let schemaFactory = String((await loadUserConfig()).defaultSchemaFactory ?? '').trim();
307
+ let schemaFactoryResolved = false;
308
+ const schemaByMethod = new Map();
309
+ const schemaImports = [];
310
+ let schemaIndexNeeded = false;
311
+ if (mutationMethods.length) {
312
+ for (const method of mutationMethods) {
313
+ const requestParam = method.params.find((item) => !isPathParamName(item.name));
314
+ if (!requestParam) continue;
315
+ const { shouldCreateSchema } = await prompts({
316
+ type: 'confirm',
317
+ name: 'shouldCreateSchema',
318
+ message: `Create schema for "${method.name}"?`,
319
+ initial: false
320
+ });
321
+ if (!shouldCreateSchema) continue;
322
+ if (!schemaFactoryResolved) {
323
+ if (!schemaFactory) {
324
+ const availableSchemas = await getSharedSchemaFactories();
325
+ if (!availableSchemas.length) {
326
+ console.error('❌ No schema factories found in shared foundation constructs/schema.');
327
+ process.exitCode = 1;
328
+ return;
329
+ }
330
+ const { selectedSchemaFactory } = await prompts({
331
+ type: 'select',
332
+ name: 'selectedSchemaFactory',
333
+ message: 'Select schema factory:',
334
+ choices: availableSchemas.map((item) => ({ title: item, value: item })),
335
+ initial: 0
336
+ });
337
+ schemaFactory = String(selectedSchemaFactory ?? '');
338
+ }
339
+ schemaFactoryResolved = true;
340
+ }
341
+ const schemaConstName = `${toPascalCase(method.name)}${presenterName}Schema`;
342
+ const schemaFileName = `${schemaConstName}.ts`;
343
+ const schemaPath = path.join(presentationPath, 'schema');
344
+ await fs.mkdir(schemaPath, { recursive: true });
345
+ schemaIndexNeeded = true;
346
+ const schemaContent = `import { ${schemaFactory} } from '${schemaFactoryImportPath}';
361
347
  import type { ${requestParam.type} } from '${contextAlias}/layers/domain/${useCasesInfo.domainName}';
362
348
 
363
349
  export const ${schemaConstName} = ${schemaFactory}<${requestParam.type}>()
364
350
  \t.rules((rules) => ({}))
365
351
  \t.create();
366
352
  `;
367
- await writeIfNotExists(path.join(schemaPath, schemaFileName), schemaContent);
368
- schemaByMethod.set(method.name, { constName: schemaConstName });
369
- schemaImports.push(schemaConstName);
370
- }
371
- }
372
- if (schemaIndexNeeded) {
373
- await updateIndexTs(path.join(presentationPath, 'schema'));
374
- }
375
- const hasGetLike = repositoryMethods.some((method) => {
376
- const httpMethod = repositoryHttpMethods.get(method.name) ?? 'get';
377
- return httpMethod === 'get' || httpMethod === 'head' || httpMethod === 'options';
378
- });
379
- const hasMutation = repositoryMethods.some((method) => {
380
- const httpMethod = repositoryHttpMethods.get(method.name) ?? 'get';
381
- return httpMethod !== 'get' && httpMethod !== 'head' && httpMethod !== 'options';
382
- });
383
- const helperParams = [hasGetLike ? 'createAsyncResource' : null, hasMutation ? 'createAsyncAction' : null].filter(Boolean).join(', ');
384
- const typeImports = normalizeTypeImports(repositoryMethods.flatMap((method) => [method.responseType, ...method.params.map((item) => item.type)]));
385
- const methodsCode = repositoryMethods
386
- .map((method) => {
387
- const httpMethod = repositoryHttpMethods.get(method.name) ?? 'get';
388
- return buildMethodInvocation({ ...method, httpMethod }, useCasesName, schemaByMethod);
389
- })
390
- .join('\n\n');
391
- const factoryImport = useNativePresenter
392
- ? `import { createPresenter } from '@azure-net/kit/delivery';`
393
- : `import { ${presenterFactory} } from '${presenterImportPath}';`;
394
- const schemaImportLine = schemaImports.length ? `import { ${Array.from(new Set(schemaImports)).join(', ')} } from './schema';` : '';
395
- const typeImportLine = typeImports.length
396
- ? `import type { ${typeImports.join(', ')} } from '${contextAlias}/layers/domain/${useCasesInfo.domainName}';`
397
- : '';
398
- const presenterId = `${toPascalCase(contextName)}${presenterName}`;
399
- const presenterContent = `${factoryImport}
353
+ await writeIfNotExists(path.join(schemaPath, schemaFileName), schemaContent);
354
+ schemaByMethod.set(method.name, { constName: schemaConstName });
355
+ schemaImports.push(schemaConstName);
356
+ }
357
+ }
358
+ if (schemaIndexNeeded) {
359
+ await updateIndexTs(path.join(presentationPath, 'schema'));
360
+ }
361
+ const hasGetLike = repositoryMethods.some((method) => {
362
+ const httpMethod = repositoryHttpMethods.get(method.name) ?? 'get';
363
+ return httpMethod === 'get' || httpMethod === 'head' || httpMethod === 'options';
364
+ });
365
+ const hasMutation = repositoryMethods.some((method) => {
366
+ const httpMethod = repositoryHttpMethods.get(method.name) ?? 'get';
367
+ return httpMethod !== 'get' && httpMethod !== 'head' && httpMethod !== 'options';
368
+ });
369
+ const helperParams = [hasGetLike ? 'createAsyncResource' : null, hasMutation ? 'createAsyncAction' : null].filter(Boolean).join(', ');
370
+ const typeImports = normalizeTypeImports(
371
+ repositoryMethods.flatMap((method) => [method.responseType, ...method.params.map((item) => item.type)])
372
+ );
373
+ const methodsCode = repositoryMethods
374
+ .map((method) => {
375
+ const httpMethod = repositoryHttpMethods.get(method.name) ?? 'get';
376
+ return buildMethodInvocation({ ...method, httpMethod }, useCasesName, schemaByMethod);
377
+ })
378
+ .join('\n\n');
379
+ const factoryImport = useNativePresenter
380
+ ? `import { createPresenter } from '@azure-net/kit/delivery';`
381
+ : `import { ${presenterFactory} } from '${presenterImportPath}';`;
382
+ const schemaImportLine = schemaImports.length ? `import { ${Array.from(new Set(schemaImports)).join(', ')} } from './schema';` : '';
383
+ const typeImportLine = typeImports.length
384
+ ? `import type { ${typeImports.join(', ')} } from '${contextAlias}/layers/domain/${useCasesInfo.domainName}';`
385
+ : '';
386
+ const presenterId = `${toPascalCase(contextName)}${presenterName}`;
387
+ const presenterContent = `${factoryImport}
400
388
  import { ${providerInfo.providerName} } from '${contextAlias}/layers/application/providers';
401
389
  ${typeImportLine}
402
390
  ${schemaImportLine}
@@ -408,7 +396,7 @@ ${methodsCode ? `${methodsCode}\n` : ''}
408
396
  \treturn { ${repositoryMethods.map((method) => method.name).join(', ')} };
409
397
  });
410
398
  `;
411
- await writeIfNotExists(path.join(presentationPath, `${presenterName}.ts`), presenterContent);
412
- await fs.writeFile(path.join(presentationPath, 'index.ts'), `export * from './${presenterName}';\n`, 'utf-8');
413
- console.log(`✅ Presenter generated: ${path.join(presentationPath, `${presenterName}.ts`)}`);
399
+ await writeIfNotExists(path.join(presentationPath, `${presenterName}.ts`), presenterContent);
400
+ await fs.writeFile(path.join(presentationPath, 'index.ts'), `export * from './${presenterName}';\n`, 'utf-8');
401
+ console.log(`✅ Presenter generated: ${path.join(presentationPath, `${presenterName}.ts`)}`);
414
402
  }