@domain-first/project-structure 0.0.1

package/dist/index.cjs

@@ -0,0 +1,950 @@
+#!/usr/bin/env node
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+var __webpack_exports__ = {};
+const prompts_namespaceObject = require("@inquirer/prompts");
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_zod_namespaceObject = require("zod");
+var external_zod_default = /*#__PURE__*/ __webpack_require__.n(external_zod_namespaceObject);
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+class FileSystemItem {
+    path;
+    constructor(path){
+        this.path = path;
+    }
+    subitem = (relativePath)=>new this.constructor(external_node_path_default().resolve(this.path, ...relativePath));
+    get exists() {
+        return external_node_fs_default().existsSync(this.path);
+    }
+}
+class Folder extends FileSystemItem {
+    createIfNotExisted = ()=>{
+        external_node_fs_default().mkdirSync(this.path, {
+            recursive: true
+        });
+    };
+    get content() {
+        if (!this.exists) return {
+            subfolderNames: [],
+            fileNames: []
+        };
+        const content = external_node_fs_default().readdirSync(this.path, {
+            withFileTypes: true
+        });
+        return {
+            subfolderNames: content.filter((x)=>x.isDirectory()).map((x)=>x.name),
+            fileNames: content.filter((x)=>!x.isDirectory()).map((x)=>external_node_path_default().parse(x.name).name)
+        };
+    }
+    get name() {
+        return external_node_path_default().basename(this.path);
+    }
+    createFile = (name, content)=>{
+        this.createIfNotExisted();
+        const file = new File(this.path).subitem([
+            name
+        ]);
+        file.data = content;
+        return file;
+    };
+    file = (name)=>{
+        this.createIfNotExisted();
+        const file = new File(this.path).subitem([
+            name
+        ]);
+        return file;
+    };
+}
+class File extends FileSystemItem {
+    get data() {
+        if (!this.exists) throw new Error('File does not exist');
+        return external_node_fs_default().readFileSync(this.path, 'utf-8');
+    }
+    set data(content) {
+        external_node_fs_default().writeFileSync(this.path, content);
+    }
+    addLine = (newLine, separator = '\n')=>{
+        let content = '';
+        try {
+            content = external_node_fs_default().readFileSync(this.path, 'utf8');
+        } catch  {}
+        external_node_fs_default().writeFileSync(this.path, [
+            content.trim(),
+            newLine.trim()
+        ].filter((x)=>!!x).join(separator), 'utf8');
+    };
+}
+class ProjectRoot {
+    path;
+    constructor(){
+        let dir = process.cwd();
+        while(dir !== external_node_path_default().parse(dir).root){
+            if (external_node_fs_default().existsSync(external_node_path_default().join(dir, 'package.json'))) {
+                this.path = dir;
+                return;
+            }
+            dir = external_node_path_default().dirname(dir);
+        }
+        throw new Error('No package.json was found');
+    }
+}
+const configFileName = 'domain-first.project-structure.config.json';
+const configSchema = external_zod_default().object({
+    rootFolder: external_zod_default().string(),
+    domainFirstPackages: external_zod_default().array(external_zod_default()["enum"]([
+        '@domain-first/types',
+        '@domain-first/errors',
+        '@domain-first/handlers',
+        '@domain-first/wire',
+        '@domain-first/handlers-rest'
+    ])),
+    defaultPersistenceLayerImplementation: external_zod_default().string()
+});
+class ConfigFile {
+    data;
+    constructor(){
+        const filePath = ConfigFile.path;
+        const file = new File(filePath);
+        const configObject = JSON.parse(file.data);
+        this.data = configSchema.parse(configObject);
+    }
+    static get Instance() {
+        return new ConfigFile();
+    }
+    static get path() {
+        const { path: root } = new ProjectRoot();
+        return external_node_path_default().resolve(root, configFileName);
+    }
+    static get exists() {
+        return new File(ConfigFile.path).exists;
+    }
+    static write = (config)=>{
+        new File(ConfigFile.path).data = JSON.stringify(config, null, '\t');
+    };
+}
+const initializeUseCase = async ()=>{
+    const rootFolderName = await (0, prompts_namespaceObject.input)({
+        message: 'Root folder (use "/" for inner folders):',
+        default: 'src'
+    });
+    const domainFirstPackages = await (0, prompts_namespaceObject.checkbox)({
+        message: '@domain-first packages',
+        choices: [
+            '@domain-first/types',
+            '@domain-first/errors',
+            '@domain-first/handlers',
+            '@domain-first/wire',
+            '@domain-first/handlers-rest'
+        ]
+    });
+    const defaultPersistenceLayerImplementation = await (0, prompts_namespaceObject.input)({
+        message: 'Default persistence layer implementation:'
+    });
+    ConfigFile.write({
+        rootFolder: rootFolderName,
+        domainFirstPackages,
+        defaultPersistenceLayerImplementation
+    });
+    const { path } = new ProjectRoot();
+    const rootFolder = new Folder(path);
+    if (domainFirstPackages.includes('@domain-first/wire')) rootFolder.subitem([
+        rootFolderName,
+        'shared',
+        'wiring'
+    ]).createFile('env-branched-wire.ts', `
+import { branchedWire } from '@domain-first/wire'
+
+export const envBranchedWire = branchedWire(() => {
+    return process.env.NODE_ENV as 'test' | 'development' | 'production'
+});
+`);
+    if (domainFirstPackages.includes('@domain-first/errors')) rootFolder.subitem([
+        rootFolderName,
+        'shared'
+    ]).subitem([
+        'domain',
+        'errors'
+    ]).createFile('index.ts', `
+import { errorNamespace } from '@domain-first/errors'
+
+export const SharedErrors = errorNamespace('shared')
+            `.trim());
+};
+class UnknownFormatNaming {
+    rawSource;
+    camelCase;
+    PascalCase;
+    constructor(rawSource){
+        this.rawSource = rawSource;
+        const source = rawSource.trim();
+        if (!source.includes('-')) {
+            this.camelCase = source.substring(0, 1).toLowerCase() + source.substring(1);
+            this.PascalCase = source.substring(0, 1).toUpperCase() + source.substring(1);
+        }
+        const words = source.split('-');
+        this.camelCase = words.map((word, index)=>0 === index ? word.toLowerCase() : word[0].toUpperCase() + word.slice(1).toLowerCase()).join('');
+        this.PascalCase = words.map((word)=>word[0].toUpperCase() + word.slice(1).toLowerCase()).join('');
+    }
+    get fileName() {
+        return this.rawSource;
+    }
+    get variableName() {
+        return this.camelCase;
+    }
+    get ClassName() {
+        return this.PascalCase;
+    }
+}
+const scaffoldNewAggregateUseCase = async (boundedContextFolder)=>{
+    const aggregateName = await (0, prompts_namespaceObject.input)({
+        message: 'Aggregate name:'
+    });
+    const aggregateNaming = new UnknownFormatNaming(aggregateName);
+    const withRepository = await (0, prompts_namespaceObject.confirm)({
+        message: 'With Repository'
+    });
+    const aggregatesFolder = boundedContextFolder.subitem([
+        'domain',
+        'aggregates',
+        aggregateName
+    ]);
+    aggregatesFolder.createFile(`${aggregateNaming.fileName}.aggregate-root.ts`, ConfigFile.Instance.data.domainFirstPackages.includes('@domain-first/types') ? `
+import { domainType } from '@domain-first/types'
+
+export class ${aggregateNaming.ClassName} extends domainType() {
+
+}`.trim() : `export class ${aggregateNaming.ClassName} {}`);
+    const barrelFile = aggregatesFolder.createFile("index.ts", `export * from './${aggregateNaming.fileName}.aggregate-root'`);
+    if (withRepository) {
+        aggregatesFolder.createFile(`${aggregateNaming.fileName}-repository.ts`, `export abstract class ${aggregateNaming.ClassName}Repository { }`);
+        barrelFile.addLine(`export * from './${aggregateNaming.fileName}-repository'`);
+        const infrastructureImplementationType = await (0, prompts_namespaceObject.input)({
+            message: 'Repository infrastructure implementation type:',
+            default: 'prisma'
+        });
+        let addTestImplementation = false;
+        let testImplementationType = '';
+        addTestImplementation = await (0, prompts_namespaceObject.confirm)({
+            message: 'Add a test implementation for Repository'
+        });
+        if (addTestImplementation) testImplementationType = await (0, prompts_namespaceObject.input)({
+            message: 'Test Repository infrastructure implementation type:',
+            default: 'in-memory'
+        });
+        const infrastructureRepositoriesFolder = boundedContextFolder.subitem([
+            'infrastructure',
+            'repositories'
+        ]);
+        const implementationTypes = [
+            infrastructureImplementationType,
+            testImplementationType
+        ].filter((x)=>!!x);
+        for (const implementation of implementationTypes){
+            const naming = new UnknownFormatNaming(implementation);
+            infrastructureRepositoriesFolder.subitem([
+                naming.fileName
+            ]).createFile(`${naming.fileName}-${aggregateName}-repository.ts`, `
+import { ${aggregateNaming.ClassName}Repository } from '../../../domain/aggregates/${aggregateName}'
+
+export class ${naming.ClassName}${aggregateNaming.ClassName}Repository implements ${aggregateNaming.ClassName}Repository {
+    constructor() {}
+}
+
+                        `.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')}
+
+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
+})
+`.trim());
+        }
+    }
+};
+const scaffoldNewApplicationPort = async (boundedContextFolder)=>{
+    const name = await (0, prompts_namespaceObject.input)({
+        message: 'Name: '
+    });
+    const naming = new UnknownFormatNaming(name);
+    const wiringFolder = boundedContextFolder.subitem([
+        'wiring',
+        'application',
+        'ports',
+        naming.fileName
+    ]);
+    const infraFolder = boundedContextFolder.subitem([
+        'wiring',
+        'infrastructure',
+        'application-ports'
+    ]);
+    const applicationPortsFolder = boundedContextFolder.subitem([
+        'application',
+        'ports'
+    ]);
+    applicationPortsFolder.createFile(`${naming.fileName}.ts`, `
+export abstract class ${naming.ClassName} {
+
+}
+            `.trim());
+    const implementationType = await (0, prompts_namespaceObject.input)({
+        message: 'Adapter implementation type:'
+    });
+    const addTestImplementation = await (0, prompts_namespaceObject.confirm)({
+        message: 'With test implementation'
+    });
+    let testImplementationType = '';
+    if (addTestImplementation) testImplementationType = await (0, prompts_namespaceObject.input)({
+        message: 'Test adapter implementation type:',
+        default: 'mock'
+    });
+    const infrastructureFolder = boundedContextFolder.subitem([
+        'infrastructure',
+        'application-adapters'
+    ]);
+    const implementationTypes = [
+        implementationType,
+        testImplementationType
+    ].filter((x)=>!!x);
+    for (const implementation of implementationTypes){
+        const currentNaming = new UnknownFormatNaming(`${implementation}-${naming.fileName}`);
+        infrastructureFolder.subitem([
+            implementation
+        ]).createFile(`${currentNaming.fileName}.ts`, `
+import { ${naming.ClassName} } from '../../../application/ports/${naming.fileName}'
+
+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'
+${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')}
+
+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}
+})
+
+                `.trim());
+};
+const scaffoldNewBoundedContextUseCase = async ()=>{
+    const name = await (0, prompts_namespaceObject.input)({
+        message: 'Name:',
+        validate: (x)=>!!x.length
+    });
+    const { path } = new ProjectRoot();
+    const rootFolder = new Folder(path);
+    const folder = rootFolder.subitem([
+        ConfigFile.Instance.data.rootFolder,
+        'bounded-contexts',
+        name
+    ]);
+    if (ConfigFile.Instance.data.domainFirstPackages.includes('@domain-first/errors')) folder.subitem([
+        'domain',
+        'errors'
+    ]).createFile('index.ts', `
+import { errorNamespace } from '@domain-first/errors'
+
+export const ${new UnknownFormatNaming(name).ClassName}Errors = errorNamespace('${name}')
+            `.trim());
+    folder.createIfNotExisted();
+};
+const scaffoldNewCommand = async (boundedContextFolder)=>{
+    const commandsFolder = boundedContextFolder.subitem([
+        'application',
+        'commands'
+    ]);
+    const infrastructureFolder = boundedContextFolder.subitem([
+        'infrastructure',
+        'commands'
+    ]);
+    const commandName = await (0, prompts_namespaceObject.input)({
+        message: 'Name: '
+    });
+    const naming = new UnknownFormatNaming(commandName);
+    const implementationType = await (0, prompts_namespaceObject.input)({
+        message: 'Command infrastructure implementation type:',
+        default: ConfigFile.Instance.data.defaultPersistenceLayerImplementation
+    });
+    let addTestImplementation = false;
+    let testImplementationType = '';
+    addTestImplementation = await (0, prompts_namespaceObject.confirm)({
+        message: 'Add a test implementation for Command'
+    });
+    if (addTestImplementation) testImplementationType = await (0, prompts_namespaceObject.input)({
+        message: 'Test Command infrastructure implementation type:',
+        default: 'in-memory'
+    });
+    const implementationTypes = [
+        implementationType,
+        testImplementationType
+    ].filter((x)=>!!x);
+    for (const implementation of implementationTypes){
+        const formatNaming = new UnknownFormatNaming(implementation);
+        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() {}
+
+    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 implements ${naming.ClassName}Command {
+
+}
+`.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'
+
+export abstract class ${naming.ClassName}Command {
+    static inputSchema = {}
+    static 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 {
+
+}`.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')}
+
+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
+})
+`.trim());
+    }
+};
+const scaffoldNewDomainService = async (boundedContextFolder)=>{
+    const portName = await (0, prompts_namespaceObject.input)({
+        message: 'Name:'
+    });
+    const naming = new UnknownFormatNaming(portName);
+    boundedContextFolder.subitem([
+        'domain',
+        'services'
+    ]).createFile(`${naming.fileName}-service.ts`, `
+export class ${naming.ClassName}Service {
+
+}
+        `.trim());
+    if (ConfigFile.Instance.data.domainFirstPackages.includes('@domain-first/wire')) boundedContextFolder.subitem([
+        'wiring',
+        'domain',
+        'services'
+    ]).createFile(`wire-${naming.fileName}-service.ts`, `
+import { wireClass } from '@domain-first/wire'
+import { ${naming.ClassName}Service } from '../../../domain/services/${naming.fileName}-service'
+
+export const wire${naming.ClassName}Service = wireClass(
+    ${naming.ClassName}Service,
+    []
+)
+            `.trim());
+};
+const scaffoldNewErrorUseCase = async (boundedContextFolder)=>{
+    const currentErrorFolder = boundedContextFolder.subitem([
+        'domain',
+        'errors'
+    ]);
+    const currentErrorNamespaces = currentErrorFolder.content.fileNames.filter((x)=>'index' !== x);
+    const variants = [
+        'New error without namespace',
+        ...currentErrorNamespaces.map((x)=>`New error in namespace ${x}`),
+        'New namespace'
+    ];
+    const selectedVariant = await (0, prompts_namespaceObject.select)({
+        choices: variants,
+        message: 'Action:'
+    });
+    if ('New error without namespace' === selectedVariant) {
+        const errorName = await (0, prompts_namespaceObject.input)({
+            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');
+        return;
+    }
+    if ('New namespace' === selectedVariant) {
+        const namespaceName = await (0, prompts_namespaceObject.input)({
+            message: 'Namespace name:'
+        });
+        const { ClassName, fileName } = new UnknownFormatNaming(namespaceName);
+        currentErrorFolder.createFile(`${fileName}.ts`, `
+import { errorNamespace } from '@domain-first/errors'
+
+const ${ClassName}Errors = errorNamespace('${boundedContextFolder.name}').subnamespace('${fileName}')
+`);
+        currentErrorFolder.file('index.ts').addLine(`export * from './${fileName}'`);
+        return;
+    }
+    const namespace = selectedVariant.substring(23);
+    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');
+};
+const scaffoldNewHandlersRestEndpoint = async (boundedContextFolder)=>{
+    const restPresentationFolder = boundedContextFolder.subitem([
+        'presentation',
+        'rest'
+    ]);
+    const controllers = restPresentationFolder.content.subfolderNames;
+    let controller = await (0, prompts_namespaceObject.select)({
+        message: 'Controller: ',
+        choices: [
+            ...controllers,
+            'New controller'
+        ]
+    });
+    if ('New controller' === controller) {
+        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}'`);
+    }
+    const method = await (0, prompts_namespaceObject.select)({
+        message: 'Method:',
+        choices: [
+            'get',
+            'post',
+            'patch',
+            'delete',
+            'put'
+        ]
+    });
+    const path = (await (0, prompts_namespaceObject.input)({
+        message: 'Relative path (split by "/"):'
+    })).split('/').filter((x)=>!!x);
+    const controllerFolder = restPresentationFolder.subitem([
+        controller
+    ]);
+    const nameBase = `${controller}-${path.length ? `${path.join('-')}-` : ''}${method}-endpoint`;
+    const endpointNaming = new UnknownFormatNaming(nameBase);
+    controllerFolder.createFile(`${endpointNaming.fileName}.ts`, `
+import { EndpointGenerator } from '@domain-first/handlers-rest'
+
+export class ${endpointNaming.ClassName} {
+    constructor(private readonly endpointGenerator: EndpointGenerator) {}
+
+    get logic() {
+        return () => {}
+    }
+
+    get handle() {
+        return this.endpointGenerator(this.logic, {
+            route: { method: '${method}', path: ['${controller}'${path.length ? `, ${path.map((x)=>`'${x}'`).join(', ')}` : ''}] },
+            tags: ['${boundedContextFolder.name}: ${controller}'],
+        })
+    }
+
+}
+        `.trim());
+    if (ConfigFile.Instance.data.domainFirstPackages.includes('@domain-first/wire')) {
+        const wiringFolder = boundedContextFolder.subitem([
+            'wiring',
+            'presentation',
+            'rest',
+            controller
+        ]);
+        const wireNameBase = `wire-${nameBase}`;
+        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}'
+
+export const wire${endpointNaming.ClassName} = wireClass(
+    ${endpointNaming.ClassName},
+    []
+)
+        `);
+        wiringFolder.file('index.ts').addLine(`export * from './${wireNaming.fileName}'`);
+    }
+};
+const scaffoldNewQuery = async (boundedContextFolder)=>{
+    const queriesFolder = boundedContextFolder.subitem([
+        'application',
+        'queries'
+    ]);
+    const infrastructureFolder = boundedContextFolder.subitem([
+        'infrastructure',
+        'queries'
+    ]);
+    const queryName = await (0, prompts_namespaceObject.input)({
+        message: 'Name: '
+    });
+    const naming = new UnknownFormatNaming(queryName);
+    const implementationType = await (0, prompts_namespaceObject.input)({
+        message: 'Query infrastructure implementation type:',
+        default: ConfigFile.Instance.data.defaultPersistenceLayerImplementation
+    });
+    let addTestImplementation = false;
+    let testImplementationType = '';
+    addTestImplementation = await (0, prompts_namespaceObject.confirm)({
+        message: 'Add a test implementation for Query'
+    });
+    if (addTestImplementation) testImplementationType = await (0, prompts_namespaceObject.input)({
+        message: 'Test Query infrastructure implementation type:',
+        default: 'in-memory'
+    });
+    const implementationTypes = [
+        implementationType,
+        testImplementationType
+    ].filter((x)=>!!x);
+    for (const implementation of implementationTypes){
+        const formatNaming = new UnknownFormatNaming(implementation);
+        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() {}
+
+    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 implements ${naming.ClassName}Query {
+
+}
+`.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'
+
+export abstract class ${naming.ClassName}Query {
+    static inputSchema = {}
+    static 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 {
+
+}`.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')}
+
+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
+})
+`.trim());
+    }
+};
+const scaffoldNewUseCase = async (boundedContextFolder)=>{
+    const useCasesFolder = boundedContextFolder.subitem([
+        'application',
+        'use-cases'
+    ]);
+    const useCaseName = await (0, prompts_namespaceObject.input)({
+        message: 'Name: '
+    });
+    const naming = new UnknownFormatNaming(useCaseName);
+    useCasesFolder.createFile(`${naming.fileName}-use-case.ts`, ConfigFile.Instance.data.domainFirstPackages.includes('@domain-first/handlers') ? `
+import { defineHandler } from '@domain-first/handlers'
+
+export class ${naming.ClassName}UseCase {
+    constructor() {}
+
+    static inputSchema = {}
+    static outputSchema = {}
+
+    handle = defineHandler({
+        inputSchema: ${naming.ClassName}UseCase.inputSchema,
+        outputSchema: ${naming.ClassName}UseCase.outputSchema,
+        handler: async (input) => {
+            return {}
+        }
+    })
+}
+        `.trim() : `
+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'
+
+export const wire${naming.ClassName}UseCase = wireClass(
+    ${naming.ClassName}UseCase,
+    []
+)
+
+`.trim());
+};
+const main = async ()=>{
+    if (!ConfigFile.exists) return void await initializeUseCase();
+    const rootPath = new ProjectRoot().path;
+    const currentBoundedContextOptions = new Folder(rootPath).subitem([
+        ConfigFile.Instance.data.rootFolder,
+        'bounded-contexts'
+    ]).content.subfolderNames.map((name)=>({
+            name: `Bounded Context: ${name}`,
+            action: 'Scaffold in bounded context'
+        }));
+    const scaffoldNewBoundedContext = {
+        name: 'Scaffold new bounded context',
+        action: 'Scaffold new bounded context'
+    };
+    const options = [
+        ...currentBoundedContextOptions,
+        {
+            name: 'Shared Layer',
+            action: 'Scaffold in bounded context'
+        },
+        scaffoldNewBoundedContext
+    ];
+    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 new bounded context':
+            return void await scaffoldNewBoundedContextUseCase();
+        case 'Scaffold in bounded context':
+            {
+                const specificContext = name.startsWith('Bounded');
+                const boundedContextFolder = new Folder(new ProjectRoot().path).subitem(specificContext ? [
+                    ConfigFile.Instance.data.rootFolder,
+                    'bounded-contexts',
+                    name.substring(17)
+                ] : [
+                    ConfigFile.Instance.data.rootFolder,
+                    'shared'
+                ]);
+                const layer = await (0, prompts_namespaceObject.select)({
+                    message: 'Layer:',
+                    choices: [
+                        'Domain',
+                        'Application',
+                        'Presentation'
+                    ]
+                });
+                if ('Domain' === layer) {
+                    const operation = await (0, prompts_namespaceObject.select)({
+                        message: 'Domain layer operation:',
+                        choices: specificContext ? [
+                            'New Aggregate',
+                            'Errors',
+                            'New Service'
+                        ] : [
+                            'Errors'
+                        ]
+                    });
+                    switch(operation){
+                        case 'New Aggregate':
+                            return void await scaffoldNewAggregateUseCase(boundedContextFolder);
+                        case 'Errors':
+                            return void await scaffoldNewErrorUseCase(boundedContextFolder);
+                        case 'New Service':
+                            return void await scaffoldNewDomainService(boundedContextFolder);
+                    }
+                }
+                if ('Application' === layer) {
+                    const operation = await (0, prompts_namespaceObject.select)({
+                        message: 'Application layer operation:',
+                        choices: specificContext ? [
+                            'New Query',
+                            'New Command',
+                            'New Use Case',
+                            'New Port'
+                        ] : [
+                            'New Port'
+                        ]
+                    });
+                    switch(operation){
+                        case 'New Query':
+                            return void await scaffoldNewQuery(boundedContextFolder);
+                        case 'New Command':
+                            return void await scaffoldNewCommand(boundedContextFolder);
+                        case 'New Use Case':
+                            return void await scaffoldNewUseCase(boundedContextFolder);
+                        case 'New Port':
+                            return void await scaffoldNewApplicationPort(boundedContextFolder);
+                    }
+                }
+                if ('Presentation' === layer) {
+                    const action = await (0, prompts_namespaceObject.select)({
+                        message: 'Presentation layer operation:',
+                        choices: specificContext ? [
+                            ConfigFile.Instance.data.domainFirstPackages.includes('@domain-first/handlers-rest') ? 'New Handlers-REST Endpoint' : void 0
+                        ].filter((x)=>x) : [
+                            ''
+                        ]
+                    });
+                    switch(action){
+                        case 'New Handlers-REST Endpoint':
+                            return void await scaffoldNewHandlersRestEndpoint(boundedContextFolder);
+                    }
+                }
+                return;
+            }
+        default:
+            return;
+    }
+};
+main();
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});