@domain-first/project-structure 1.1.3 → 2.0.0

package/dist/index.cjs

@@ -124,7 +124,8 @@ const configSchema = external_zod_default().object({
         '@domain-first/wire',
         '@domain-first/handlers-rest'
     ])),
-    defaultPersistenceLayerImplementation: external_zod_default().string()
+    defaultPersistenceLayerImplementation: external_zod_default().string(),
+    useReact: external_zod_default().boolean()
 });
 class ConfigFile {
     data;
@@ -166,10 +167,14 @@ const initializeUseCase = async ()=>{
     const defaultPersistenceLayerImplementation = await (0, prompts_namespaceObject.input)({
         message: 'Default persistence layer implementation:'
     });
+    const useReact = await (0, prompts_namespaceObject.confirm)({
+        message: 'Use React'
+    });
     ConfigFile.write({
         rootFolder: rootFolderName,
         domainFirstPackages,
-        defaultPersistenceLayerImplementation
+        defaultPersistenceLayerImplementation,
+        useReact
     });
     const { path } = new ProjectRoot();
     const rootFolder = new Folder(path);
@@ -277,41 +282,26 @@ export class ${naming.ClassName}${aggregateNaming.ClassName}Repository implement
 }
 
                         `.trim());
-            if (ConfigFile.Instance.data.domainFirstPackages.includes('@domain-first/wire')) {
-                const wiringFolder = boundedContextFolder.subitem([
-                    'wiring',
-                    'infrastructure',
-                    'repositories',
-                    naming.fileName
-                ]);
-                wiringFolder.createFile(`wire-${naming.fileName}-${aggregateNaming.fileName}-repository.ts`, `
-import { wireClass } from '@domain-first/wire'
-import { ${naming.ClassName}${aggregateNaming.ClassName}Repository } from '../../../../infrastructure/repositories/${naming.fileName}/${naming.fileName}-${aggregateNaming.fileName}-repository'
-
-export const wire${naming.ClassName}${aggregateNaming.ClassName}Repository = wireClass(
-    ${naming.ClassName}${aggregateNaming.ClassName}Repository,
-    []
-)
-    `.trim());
-            }
         }
         if (ConfigFile.Instance.data.domainFirstPackages.includes('@domain-first/wire')) {
             const implementationNaming = new UnknownFormatNaming(infrastructureImplementationType);
             const testImplementationNaming = new UnknownFormatNaming(testImplementationType);
             boundedContextFolder.subitem([
                 'wiring',
-                'domain',
                 'repositories'
             ]).createFile(`wire-${aggregateNaming.fileName}-repository.ts`, `
-import { envBranchedWire } from '../../../../../shared/wiring/env-branched-wire'
-${implementationTypes.map((x)=>new UnknownFormatNaming(x)).map(({ ClassName, fileName })=>`import { wire${ClassName}${aggregateNaming.ClassName}Repository } from '../../infrastructure/repositories/${fileName}/wire-${fileName}-${aggregateNaming.fileName}-repository'`).join('\n')}
+import { wireClass } from '@domain-first/wire'
+import { envBranchedWire } from '../../../../shared/wiring/env-branched-wire'
+${implementationTypes.map((x)=>new UnknownFormatNaming(x)).map(({ ClassName, fileName })=>`import { ${ClassName}${aggregateNaming.ClassName}Repository } from '../../infrastructure/repositories/${fileName}/${fileName}-${aggregateNaming.fileName}-repository'`).join('\n')}
+
+${implementationTypes.map((x)=>new UnknownFormatNaming(x)).map(({ ClassName })=>`const wire${ClassName}Implementation = wireClass(${ClassName}${aggregateNaming.ClassName}Repository, [])`).join('\n\n')}
 
 export const wire${aggregateNaming.ClassName}Repository = envBranchedWire({
-    test: wire${addTestImplementation ? testImplementationNaming.ClassName : implementationNaming.ClassName}${aggregateNaming.ClassName}Repository,
-    development: wire${implementationNaming.ClassName}${aggregateNaming.ClassName}Repository,
-    production: wire${implementationNaming.ClassName}${aggregateNaming.ClassName}Repository
+    test: wire${addTestImplementation ? testImplementationNaming.ClassName : implementationNaming.ClassName}Implementation,
+    development: wire${implementationNaming.ClassName}Implementation,
+    production: wire${implementationNaming.ClassName}Implementation
 })
-`.trim());
+    `.trim());
         }
     }
 };
@@ -322,14 +312,8 @@ const scaffoldNewApplicationPort = async (boundedContextFolder)=>{
     const naming = new UnknownFormatNaming(name);
     const wiringFolder = boundedContextFolder.subitem([
         'wiring',
-        'application',
         'ports'
     ]);
-    const infraFolder = boundedContextFolder.subitem([
-        'wiring',
-        'infrastructure',
-        'application-ports'
-    ]);
     const applicationPortsFolder = boundedContextFolder.subitem([
         'application',
         'ports'
@@ -369,29 +353,24 @@ export class ${currentNaming.ClassName} extends ${naming.ClassName} {
 
 }
             `);
-        if (ConfigFile.Instance.data.domainFirstPackages.includes('@domain-first/wire')) infraFolder.subitem([
-            implementation
-        ]).createFile(`wire-${currentNaming.fileName}.ts`, `
-import { wireClass } from '@domain-first/wire'
-import { ${currentNaming.ClassName} } from '../../../../infrastructure/application-adapters/${implementation}/${currentNaming.fileName}'
-
-export const wire${currentNaming.ClassName} = wireClass(
-    ${currentNaming.ClassName},
-    []
-)
-`.trim());
     }
     if (ConfigFile.Instance.data.domainFirstPackages.includes('@domain-first/wire')) wiringFolder.createFile(`wire-${naming.fileName}.ts`, `
-import { envBranchedWire } from '../../../../${'shared' === boundedContextFolder.name ? '' : '../'}shared/wiring/env-branched-wire'
+import { wireClass } from '@domain-first/wire'
+import { envBranchedWire } from '../../../${'shared' === boundedContextFolder.name ? '' : '../'}shared/wiring/env-branched-wire'
+${implementationTypes.map((x)=>({
+            naming: new UnknownFormatNaming(`${x}-${naming.fileName}`),
+            implementation: x
+        })).map(({ naming: { ClassName, fileName }, implementation })=>`import { ${ClassName} } from '../../infrastructure/application-adapters/${implementation}/${fileName}'`).join('\n')}
+
 ${implementationTypes.map((x)=>({
             naming: new UnknownFormatNaming(`${x}-${naming.fileName}`),
             implementation: x
-        })).map(({ naming: { ClassName, fileName }, implementation })=>`import { wire${ClassName} } from '../../infrastructure/application-ports/${implementation}/wire-${fileName}'`).join('\n')}
+        })).map(({ naming: { ClassName }, implementation })=>`const wire${new UnknownFormatNaming(implementation).ClassName}Implementation = wireClass(${ClassName}, [])`).join('\n\n')}
 
 export const wire${naming.ClassName} = envBranchedWire({
-    test: wire${new UnknownFormatNaming(`${implementationTypes.at(-1)}-${naming.fileName}`).ClassName},
-    development: wire${new UnknownFormatNaming(`${implementationTypes.at(0)}-${naming.fileName}`).ClassName},
-    production: wire${new UnknownFormatNaming(`${implementationTypes.at(0)}-${naming.fileName}`).ClassName}
+    test: wire${new UnknownFormatNaming(`${implementationTypes.at(-1)}-implementation`).ClassName},
+    development: wire${new UnknownFormatNaming(`${implementationTypes.at(0)}-implementation`).ClassName},
+    production: wire${new UnknownFormatNaming(`${implementationTypes.at(0)}-implementation`).ClassName}
 })
 
                 `.trim());
@@ -431,9 +410,14 @@ const scaffoldNewCommand = async (boundedContextFolder)=>{
         message: 'Name: '
     });
     const naming = new UnknownFormatNaming(commandName);
-    const isOrchestrator = await (0, prompts_namespaceObject.confirm)({
-        message: 'Is an orchestrator command (no infrastructure implementations)?'
+    const commandType = await (0, prompts_namespaceObject.select)({
+        choices: [
+            'Execution (with infrastructure implementation)',
+            'Orchestrator (no infrastructure implementation)'
+        ],
+        message: 'Command type'
     });
+    const isOrchestrator = 'Orchestrator (no infrastructure implementation)' === commandType;
     if (!isOrchestrator) {
         const implementationType = await (0, prompts_namespaceObject.input)({
             message: 'Command infrastructure implementation type:',
@@ -457,81 +441,73 @@ const scaffoldNewCommand = async (boundedContextFolder)=>{
             infrastructureFolder.subitem([
                 formatNaming.fileName
             ]).createFile(`${formatNaming.fileName}-${naming.fileName}-command.ts`, ConfigFile.Instance.data.domainFirstPackages.includes('@domain-first/handlers') ? `
-    import { defineHandler } from '@domain-first/handlers'
-    import { ${naming.ClassName}Command } from '../../../application/commands/${naming.fileName}-command'
-
-    export class ${formatNaming.ClassName}${naming.ClassName}Command implements ${naming.ClassName}Command {
-        constructor() {}
+import { defineHandler } from '@domain-first/handlers'
+import { ${naming.ClassName}Command } from '../../../application/commands/execution/${naming.fileName}-command'
 
-        handle = defineHandler({
-            inputSchema: ${naming.ClassName}Command.inputSchema,
-            outputSchema: ${naming.ClassName}Command.outputSchema,
-            handler: async (input) => {
-                return {}
-            }
-        })
+export class ${formatNaming.ClassName}${naming.ClassName}Command extends ${naming.ClassName}Command {
+    constructor() {
+        super()
     }
-        `.trim() : `
-    import { ${naming.ClassName}Command } from '../../../domain/commands/${naming.fileName}-command'
 
-    export class ${formatNaming.ClassName}${naming.ClassName}Command implements ${naming.ClassName}Command {
+    handle = defineHandler({
+        inputSchema: ${naming.ClassName}Command.inputSchema,
+        outputSchema: ${naming.ClassName}Command.outputSchema,
+        handler: async (input) => {
+            return {}
+        }
+    })
+}
+        `.trim() : `
+import { ${naming.ClassName}Command } from '../../../domain/commands/${naming.fileName}-command'
 
+export class ${formatNaming.ClassName}${naming.ClassName}Command extends ${naming.ClassName}Command {
+    constructor() {
+        super()
     }
+}
     `.trim());
-            if (ConfigFile.Instance.data.domainFirstPackages.includes('@domain-first/wire')) {
-                const wiringFolder = boundedContextFolder.subitem([
-                    'wiring',
-                    'infrastructure',
-                    'commands',
-                    formatNaming.fileName
-                ]);
-                wiringFolder.createFile(`wire-${formatNaming.fileName}-${naming.fileName}-command.ts`, `
-    import { wireClass } from '@domain-first/wire'
-    import { ${formatNaming.ClassName}${naming.ClassName}Command } from '../../../../infrastructure/commands/${formatNaming.fileName}/${formatNaming.fileName}-${naming.fileName}-command'
-
-    export const wire${formatNaming.ClassName}${naming.ClassName}Command = wireClass(
-        ${formatNaming.ClassName}${naming.ClassName}Command,
-        []
-    )
-
-                    `.trim());
-            }
         }
-        if (ConfigFile.Instance.data.domainFirstPackages.includes('@domain-first/handlers')) commandsFolder.createFile(`${naming.fileName}-command.ts`, `
-    import type { Handler } from '@domain-first/handlers'
+        if (ConfigFile.Instance.data.domainFirstPackages.includes('@domain-first/handlers')) commandsFolder.subitem([
+            'execution'
+        ]).createFile(`${naming.fileName}-command.ts`, `
+import type { Handler } from '@domain-first/handlers'
 
-    export abstract class ${naming.ClassName}Command {
-        static inputSchema = {}
-        static outputSchema = {}
+export abstract class ${naming.ClassName}Command {
+    static inputSchema = {}
+    static outputSchema = {}
 
-        abstract handle: Handler<typeof ${naming.ClassName}Command.inputSchema, typeof ${naming.ClassName}Command.outputSchema>
-    }
+    abstract handle: Handler<typeof ${naming.ClassName}Command.inputSchema, typeof ${naming.ClassName}Command.outputSchema>
+}
                     `.trim());
         else commandsFolder.createFile(`${naming.fileName}-command.ts`, `
-    export abstract class ${naming.ClassName}Command {
+export abstract class ${naming.ClassName}Command {
 
-    }`.trim());
+}`.trim());
         if (ConfigFile.Instance.data.domainFirstPackages.includes('@domain-first/wire')) {
             const implementationNaming = new UnknownFormatNaming(implementationType);
             const testImplementationNaming = new UnknownFormatNaming(testImplementationType);
             boundedContextFolder.subitem([
                 'wiring',
-                'application',
                 'commands'
             ]).createFile(`wire-${naming.fileName}-command.ts`, `
-    import { envBranchedWire } from '../../../../../shared/wiring/env-branched-wire'
-    ${implementationTypes.map((x)=>new UnknownFormatNaming(x)).map(({ ClassName, fileName })=>`import { wire${ClassName}${naming.ClassName}Command } from '../../infrastructure/commands/${fileName}/wire-${fileName}-${naming.fileName}-command'`).join('\n')}
+import { wireClass } from '@domain-first/wire'
+import { envBranchedWire } from '../../../../shared/wiring/env-branched-wire'
+${implementationTypes.map((x)=>new UnknownFormatNaming(x)).map(({ ClassName, fileName })=>`import { ${ClassName}${naming.ClassName}Command } from '../../infrastructure/commands/${fileName}/${fileName}-${naming.fileName}-command'`).join('\n')}
 
-    export const wire${naming.ClassName}Command = envBranchedWire({
-        test: wire${addTestImplementation ? testImplementationNaming.ClassName : implementationNaming.ClassName}${naming.ClassName}Command,
-        development: wire${implementationNaming.ClassName}${naming.ClassName}Command,
-        production: wire${implementationNaming.ClassName}${naming.ClassName}Command
-    })
+${implementationTypes.map((x)=>new UnknownFormatNaming(x)).map(({ ClassName })=>`const wire${ClassName}Implementation = wireClass(${ClassName}${naming.ClassName}Command, [])`).join('\n\n')}
+
+export const wire${naming.ClassName}Command = envBranchedWire({
+    test: wire${addTestImplementation ? testImplementationNaming.ClassName : implementationNaming.ClassName}Implementation,
+    development: wire${implementationNaming.ClassName}Implementation,
+    production: wire${implementationNaming.ClassName}Implementation
+})
     `.trim());
         }
         return;
     }
-    if (ConfigFile.Instance.data.domainFirstPackages.includes('@domain-first/handlers')) commandsFolder.createFile(`${naming.fileName}-command.ts`, `
+    if (ConfigFile.Instance.data.domainFirstPackages.includes('@domain-first/handlers')) commandsFolder.subitem([
+        'orchestration'
+    ]).createFile(`${naming.fileName}-command.ts`, `
 import { defineHandler } from '@domain-first/handlers'
 
 export class ${naming.ClassName}Command {
@@ -547,7 +523,9 @@ export class ${naming.ClassName}Command {
     })
 }
                 `.trim());
-    else commandsFolder.createFile(`${naming.fileName}-command.ts`, `
+    else commandsFolder.subitem([
+        'orchestration'
+    ]).createFile(`${naming.fileName}-command.ts`, `
 export class ${naming.ClassName}Command {
 
 }`.trim());
@@ -557,7 +535,7 @@ export class ${naming.ClassName}Command {
         'commands'
     ]).createFile(`wire-${naming.fileName}-command.ts`, `
 import { wireClass } from '@domain-first/wire'
-import { ${naming.ClassName}Command } from '../../../application/commands/${naming.fileName}-command'
+import { ${naming.ClassName}Command } from '../../../application/commands/orchestration/${naming.fileName}-command'
 
 export const wire${naming.ClassName}Command = wireClass(${naming.ClassName}Command, [])
 `.trim());
@@ -609,7 +587,7 @@ const scaffoldNewErrorUseCase = async (boundedContextFolder)=>{
             message: 'Error name:'
         });
         const naming = new UnknownFormatNaming(errorName);
-        currentErrorFolder.file('index.ts').addLine(`export const ${naming.ClassName}Error = ${new UnknownFormatNaming(boundedContextFolder.name).ClassName}Errors.define('${naming.fileName}')`, '\n\n');
+        currentErrorFolder.file('index.ts').addLine(`export const ${naming.ClassName}${new UnknownFormatNaming(boundedContextFolder.name).ClassName}Error = ${new UnknownFormatNaming(boundedContextFolder.name).ClassName}Errors.define('${naming.fileName}')`, '\n\n');
         return;
     }
     if ('New namespace' === selectedVariant) {
@@ -620,17 +598,18 @@ const scaffoldNewErrorUseCase = async (boundedContextFolder)=>{
         currentErrorFolder.createFile(`${fileName}.ts`, `
 import { errorNamespace } from '@domain-first/errors'
 
-const ${ClassName}Errors = errorNamespace('${boundedContextFolder.name}').subnamespace('${fileName}')
+export const ${ClassName}${new UnknownFormatNaming(boundedContextFolder.name).ClassName}Errors = errorNamespace('${boundedContextFolder.name}').subnamespace('${fileName}')
 `);
-        currentErrorFolder.file('index.ts').addLine(`export * from './${fileName}'`);
+        currentErrorFolder.file('index.ts').addLine(`export * from './${fileName}'`, '\n\n');
         return;
     }
     const namespace = selectedVariant.substring(23);
+    const namespaceNaming = new UnknownFormatNaming(namespace);
     const errorName = await (0, prompts_namespaceObject.input)({
         message: 'Error name:'
     });
     const { ClassName, fileName } = new UnknownFormatNaming(errorName);
-    currentErrorFolder.file(`${namespace}.ts`).addLine(`export const ${ClassName}Error = ${new UnknownFormatNaming(namespace).ClassName}Errors.define('${fileName}')`, '\n\n');
+    currentErrorFolder.file(`${namespace}.ts`).addLine(`export const ${ClassName}${namespaceNaming.ClassName}${new UnknownFormatNaming(boundedContextFolder.name).ClassName}Error = ${namespaceNaming.ClassName}${new UnknownFormatNaming(boundedContextFolder.name).ClassName}Errors.define('${fileName}')`, '\n\n');
 };
 const scaffoldNewHandlersRestEndpoint = async (boundedContextFolder)=>{
     const restPresentationFolder = boundedContextFolder.subitem([
@@ -649,11 +628,27 @@ const scaffoldNewHandlersRestEndpoint = async (boundedContextFolder)=>{
         controller = await (0, prompts_namespaceObject.input)({
             message: 'Name: '
         });
-        if (ConfigFile.Instance.data.domainFirstPackages.includes('@domain-first/wire')) boundedContextFolder.subitem([
-            'wiring',
-            'presentation',
-            'rest'
-        ]).file('index.ts').addLine(`export * from './${controller}'`);
+        if (ConfigFile.Instance.data.domainFirstPackages.includes('@domain-first/wire')) {
+            boundedContextFolder.subitem([
+                'wiring',
+                'presentation',
+                'rest'
+            ]).file('index.ts').addLine(`export * from './${controller}'`);
+            const sharedRestFolder = boundedContextFolder.subitem([
+                '..',
+                '..',
+                'presentation',
+                'rest'
+            ]);
+            sharedRestFolder.file('wires.ts').addLine(`export * from '../../bounded-contexts/${boundedContextFolder.name}/wiring/presentation/rest/${controller}'`);
+            if (!sharedRestFolder.file('index.ts').exists) sharedRestFolder.createFile('index.ts', `
+import * as wires from './wires'
+
+const restWires = Object.values(wires)
+
+export const restHandlers = restWires.map(x => x().handle)
+`.trim());
+        }
     }
     const method = await (0, prompts_namespaceObject.select)({
         message: 'Method:',
@@ -671,9 +666,10 @@ const scaffoldNewHandlersRestEndpoint = async (boundedContextFolder)=>{
     const controllerFolder = restPresentationFolder.subitem([
         controller
     ]);
+    const endpointFolder = controllerFolder.subitem(path);
     const nameBase = `${controller}-${path.length ? `${path.join('-')}-` : ''}${method}-endpoint`;
     const endpointNaming = new UnknownFormatNaming(nameBase);
-    controllerFolder.createFile(`${endpointNaming.fileName}.ts`, `
+    endpointFolder.createFile(`${method.toUpperCase()}.ts`, `
 import { EndpointGenerator } from '@domain-first/handlers-rest'
 
 export class ${endpointNaming.ClassName} {
@@ -689,7 +685,6 @@ export class ${endpointNaming.ClassName} {
             tags: ['${boundedContextFolder.name}: ${controller}'],
         })
     }
-
 }
         `.trim());
     if (ConfigFile.Instance.data.domainFirstPackages.includes('@domain-first/wire')) {
@@ -703,7 +698,7 @@ export class ${endpointNaming.ClassName} {
         const wireNaming = new UnknownFormatNaming(wireNameBase);
         wiringFolder.createFile(`${wireNaming.fileName}.ts`, `
 import { wireClass } from '@domain-first/wire'
-import { ${endpointNaming.ClassName} } from '../../../../presentation/rest/${controller}/${endpointNaming.fileName}'
+import { ${endpointNaming.ClassName} } from '../../../../presentation/rest/${controller}/${path.length ? `${path.join('/')}/` : ''}${method.toUpperCase()}'
 
 export const wire${endpointNaming.ClassName} = wireClass(
     ${endpointNaming.ClassName},
@@ -726,9 +721,14 @@ const scaffoldNewQuery = async (boundedContextFolder)=>{
         message: 'Name: '
     });
     const naming = new UnknownFormatNaming(queryName);
-    const isOrchestrator = await (0, prompts_namespaceObject.confirm)({
-        message: 'Is an orchestrator query (no infrastructure implementations)?'
+    const queryType = await (0, prompts_namespaceObject.select)({
+        choices: [
+            'Execution (with infrastructure implementation)',
+            'Orchestrator (no infrastructure implementation)'
+        ],
+        message: 'Query type'
     });
+    const isOrchestrator = 'Orchestrator (no infrastructure implementation)' === queryType;
     if (!isOrchestrator) {
         const implementationType = await (0, prompts_namespaceObject.input)({
             message: 'Query infrastructure implementation type:',
@@ -752,80 +752,73 @@ const scaffoldNewQuery = async (boundedContextFolder)=>{
             infrastructureFolder.subitem([
                 formatNaming.fileName
             ]).createFile(`${formatNaming.fileName}-${naming.fileName}-query.ts`, ConfigFile.Instance.data.domainFirstPackages.includes('@domain-first/handlers') ? `
-    import { defineHandler } from '@domain-first/handlers'
-    import { ${naming.ClassName}Query } from '../../../application/queries/${naming.fileName}-query'
-
-    export class ${formatNaming.ClassName}${naming.ClassName}Query implements ${naming.ClassName}Query {
-        constructor() {}
+import { defineHandler } from '@domain-first/handlers'
+import { ${naming.ClassName}Query } from '../../../application/queries/execution/${naming.fileName}-query'
 
-        handle = defineHandler({
-            inputSchema: ${naming.ClassName}Query.inputSchema,
-            outputSchema: ${naming.ClassName}Query.outputSchema,
-            handler: async (input) => {
-                return {}
-            }
-        })
+export class ${formatNaming.ClassName}${naming.ClassName}Query extends ${naming.ClassName}Query {
+    constructor() {
+        super()
     }
-        `.trim() : `
-    import { ${naming.ClassName}Query } from '../../../domain/queries/${naming.fileName}-query'
 
-    export class ${formatNaming.ClassName}${naming.ClassName}Query implements ${naming.ClassName}Query {
+    handle = defineHandler({
+        inputSchema: ${naming.ClassName}Query.inputSchema,
+        outputSchema: ${naming.ClassName}Query.outputSchema,
+        handler: async (input) => {
+            return {}
+        }
+    })
+}
+        `.trim() : `
+import { ${naming.ClassName}Query } from '../../../domain/queries/${naming.fileName}-query'
 
+export class ${formatNaming.ClassName}${naming.ClassName}Query extends ${naming.ClassName}Query {
+    constructor() {
+        super()
     }
+}
     `.trim());
-            if (ConfigFile.Instance.data.domainFirstPackages.includes('@domain-first/wire')) {
-                const wiringFolder = boundedContextFolder.subitem([
-                    'wiring',
-                    'infrastructure',
-                    'queries',
-                    formatNaming.fileName
-                ]);
-                wiringFolder.createFile(`wire-${formatNaming.fileName}-${naming.fileName}-query.ts`, `
-    import { wireClass } from '@domain-first/wire'
-    import { ${formatNaming.ClassName}${naming.ClassName}Query } from '../../../../infrastructure/queries/${formatNaming.fileName}/${formatNaming.fileName}-${naming.fileName}-query'
-
-    export const wire${formatNaming.ClassName}${naming.ClassName}Query = wireClass(
-        ${formatNaming.ClassName}${naming.ClassName}Query,
-        []
-    )
-    `.trim());
-            }
         }
-        if (ConfigFile.Instance.data.domainFirstPackages.includes('@domain-first/handlers')) queriesFolder.createFile(`${naming.fileName}-query.ts`, `
-    import type { Handler } from '@domain-first/handlers'
+        if (ConfigFile.Instance.data.domainFirstPackages.includes('@domain-first/handlers')) queriesFolder.subitem([
+            'execution'
+        ]).createFile(`${naming.fileName}-query.ts`, `
+import type { Handler } from '@domain-first/handlers'
 
-    export abstract class ${naming.ClassName}Query {
-        static inputSchema = {}
-        static outputSchema = {}
+export abstract class ${naming.ClassName}Query {
+    static inputSchema = {}
+    static outputSchema = {}
 
-        abstract handle: Handler<typeof ${naming.ClassName}Query.inputSchema, typeof ${naming.ClassName}Query.outputSchema>
-    }
+    abstract handle: Handler<typeof ${naming.ClassName}Query.inputSchema, typeof ${naming.ClassName}Query.outputSchema>
+}
                     `.trim());
         else queriesFolder.createFile(`${naming.fileName}-query.ts`, `
-    export abstract class ${naming.ClassName}Query {
+export abstract class ${naming.ClassName}Query {
 
-    }`.trim());
+}`.trim());
         if (ConfigFile.Instance.data.domainFirstPackages.includes('@domain-first/wire')) {
             const implementationNaming = new UnknownFormatNaming(implementationType);
             const testImplementationNaming = new UnknownFormatNaming(testImplementationType);
             boundedContextFolder.subitem([
                 'wiring',
-                'application',
                 'queries'
             ]).createFile(`wire-${naming.fileName}-query.ts`, `
-    import { envBranchedWire } from '../../../../../shared/wiring/env-branched-wire'
-    ${implementationTypes.map((x)=>new UnknownFormatNaming(x)).map(({ ClassName, fileName })=>`import { wire${ClassName}${naming.ClassName}Query } from '../../infrastructure/queries/${fileName}/wire-${fileName}-${naming.fileName}-query'`).join('\n')}
+import { wireClass } from '@domain-first/wire'
+import { envBranchedWire } from '../../../../shared/wiring/env-branched-wire'
+${implementationTypes.map((x)=>new UnknownFormatNaming(x)).map(({ ClassName, fileName })=>`import { ${ClassName}${naming.ClassName}Query } from '../../infrastructure/queries/${fileName}/${fileName}-${naming.fileName}-query'`).join('\n')}
 
-    export const wire${naming.ClassName}Query = envBranchedWire({
-        test: wire${addTestImplementation ? testImplementationNaming.ClassName : implementationNaming.ClassName}${naming.ClassName}Query,
-        development: wire${implementationNaming.ClassName}${naming.ClassName}Query,
-        production: wire${implementationNaming.ClassName}${naming.ClassName}Query
-    })
+${implementationTypes.map((x)=>new UnknownFormatNaming(x)).map(({ ClassName })=>`const wire${ClassName}Implementation = wireClass(${ClassName}${naming.ClassName}Query, [])`).join('\n\n')}
+
+export const wire${naming.ClassName}Query = envBranchedWire({
+    test: wire${addTestImplementation ? testImplementationNaming.ClassName : implementationNaming.ClassName}Implementation,
+    development: wire${implementationNaming.ClassName}Implementation,
+    production: wire${implementationNaming.ClassName}Implementation
+})
     `.trim());
         }
         return;
     }
-    if (ConfigFile.Instance.data.domainFirstPackages.includes('@domain-first/handlers')) queriesFolder.createFile(`${naming.fileName}-query.ts`, `
+    if (ConfigFile.Instance.data.domainFirstPackages.includes('@domain-first/handlers')) queriesFolder.subitem([
+        'orchestration'
+    ]).createFile(`${naming.fileName}-query.ts`, `
 import { defineHandler } from '@domain-first/handlers'
 
 export class ${naming.ClassName}Query {
@@ -841,7 +834,9 @@ export class ${naming.ClassName}Query {
     })
 }
                 `.trim());
-    else queriesFolder.createFile(`${naming.fileName}-query.ts`, `
+    else queriesFolder.subitem([
+        'orchestration'
+    ]).createFile(`${naming.fileName}-query.ts`, `
 export class ${naming.ClassName}Query {
 
 }`.trim());
@@ -851,7 +846,7 @@ export class ${naming.ClassName}Query {
         'queries'
     ]).createFile(`wire-${naming.fileName}-query.ts`, `
 import { wireClass } from '@domain-first/wire'
-import { ${naming.ClassName}Query } from '../../../application/queries/${naming.fileName}-query'
+import { ${naming.ClassName}Query } from '../../../application/queries/orchestration/${naming.fileName}-query'
 
 export const wire${naming.ClassName}Query = wireClass(${naming.ClassName}Query, [])
 `.trim());
@@ -889,11 +884,10 @@ export class ${naming.ClassName}UseCase {
 `.trim());
     if (ConfigFile.Instance.data.domainFirstPackages.includes('@domain-first/wire')) boundedContextFolder.subitem([
         'wiring',
-        'application',
         'use-cases'
     ]).createFile(`wire-${naming.fileName}-use-case.ts`, `
 import { wireClass } from '@domain-first/wire'
-import { ${naming.ClassName}UseCase } from '../../../application/use-cases/${naming.fileName}-use-case'
+import { ${naming.ClassName}UseCase } from '../../application/use-cases/${naming.fileName}-use-case'
 
 export const wire${naming.ClassName}UseCase = wireClass(
     ${naming.ClassName}UseCase,
@@ -902,6 +896,109 @@ export const wire${naming.ClassName}UseCase = wireClass(
 
 `.trim());
 };
+const scaffoldReactWidget = async (presentationReactFolder)=>{
+    const widgetName = await (0, prompts_namespaceObject.input)({
+        message: 'Name: '
+    });
+    const widgetType = await (0, prompts_namespaceObject.select)({
+        choices: [
+            'monolithic',
+            'with separated ui',
+            'headless'
+        ],
+        message: 'Type: '
+    });
+    const { ClassName, fileName } = new UnknownFormatNaming(widgetName);
+    const folder = presentationReactFolder.subitem([
+        'widgets',
+        fileName
+    ]);
+    switch(widgetType){
+        case 'monolithic':
+            folder.createFile('index.tsx', `
+import { type FC } from 'react'
+
+export type ${ClassName}WidgetProps = {}
+
+export const ${ClassName}Widget: FC<${ClassName}WidgetProps> = (props) => {
+    return <></>
+}
+            `.trim());
+            break;
+        case 'with separated ui':
+            folder.createFile('types.ts', `
+export type ${ClassName}WidgetProps = { }
+
+export type ${ClassName}WidgetUIProps = { }
+            `.trim());
+            folder.createFile('index.tsx', `
+import { type FC } from 'react'
+import type { ${ClassName}WidgetProps } from './types'
+import { ${ClassName}WidgetUI } from './ui'
+import { useUIModel } from './hooks/use-ui-model'
+
+export const ${ClassName}Widget: FC<${ClassName}WidgetProps> = (props) => {
+    const uiModel = useUIModel(props)
+    return <${ClassName}WidgetUI {...uiModel} />
+}
+
+export type { ${ClassName}WidgetProps }
+            `.trim());
+            folder.subitem([
+                'ui'
+            ]).createFile('index.tsx', `
+import { FC } from 'react'
+import type { ${ClassName}WidgetUIProps } from '../types'
+
+export const ${ClassName}WidgetUI: FC<${ClassName}WidgetUIProps> = (props) => {
+    return <></>
+}
+            `.trim());
+            folder.subitem([
+                'hooks'
+            ]).createFile('use-ui-model.ts', `
+import type { ${ClassName}WidgetProps, ${ClassName}WidgetUIProps } from '../types'
+
+export const useUIModel = (widgetProps: ${ClassName}WidgetProps): ${ClassName}WidgetUIProps => {
+    return {}
+}
+            `.trim());
+            break;
+        case 'headless':
+            folder.createFile('types.ts', `
+import { type FC } from 'react'
+
+export type ${ClassName}WidgetUIProps = { }
+
+export type ${ClassName}WidgetProps = {
+    UI: FC<${ClassName}WidgetUIProps>
+}
+
+            `.trim());
+            folder.createFile('index.tsx', `
+import { type FC } from 'react'
+import type { ${ClassName}WidgetProps } from './types'
+import { useUIModel } from './hooks/use-ui-model'
+
+export const ${ClassName}Widget: FC<${ClassName}WidgetProps> = (props) => {
+    const uiModel = useUIModel(props)
+    return <props.UI {...uiModel} />
+}
+
+export type { ${ClassName}WidgetProps }
+            `.trim());
+            folder.subitem([
+                'hooks'
+            ]).createFile('use-ui-model.ts', `
+import type { ${ClassName}WidgetProps, ${ClassName}WidgetUIProps } from '../types'
+
+export const useUIModel = (widgetProps: Omit<${ClassName}WidgetProps, 'UI'>): ${ClassName}WidgetUIProps => {
+    return {}
+}
+            `.trim());
+            break;
+    }
+};
 const main = async ()=>{
     if (!ConfigFile.exists) return void await initializeUseCase();
     const rootPath = new ProjectRoot().path;
@@ -918,18 +1015,41 @@ const main = async ()=>{
     };
     const options = [
         ...currentBoundedContextOptions,
+        ConfigFile.Instance.data.useReact ? {
+            name: 'Scaffold React module',
+            action: 'Scaffold React module'
+        } : void 0,
         {
             name: 'Shared Layer',
             action: 'Scaffold in bounded context'
         },
         scaffoldNewBoundedContext
-    ];
+    ].filter((x)=>!!x);
     const result = await (0, prompts_namespaceObject.select)({
         message: '@domain-first/project-structure',
         choices: options.map((x)=>x.name)
     });
     const { action, name } = options.find((x)=>x.name === result);
     switch(action){
+        case 'Scaffold React module':
+            {
+                const action = await (0, prompts_namespaceObject.select)({
+                    message: 'Module: ',
+                    choices: [
+                        'New widget'
+                    ]
+                });
+                switch(action){
+                    case 'New widget':
+                        return void await scaffoldReactWidget(new Folder(rootPath).subitem([
+                            ConfigFile.Instance.data.rootFolder,
+                            'presentation',
+                            'react'
+                        ]));
+                    default:
+                        return;
+                }
+            }
         case 'Scaffold new bounded context':
             return void await scaffoldNewBoundedContextUseCase();
         case 'Scaffold in bounded context':