@xeno-js/cli 0.1.0

package/src/infrastructure/generators/core/tsconfig.generator.ts

@@ -0,0 +1,39 @@
+import path from 'node:path'
+
+import type { IFileService, IGenerator } from '../../../domain'
+import { CORE_CONSTANTS, type CoreOptions } from '../../../shared'
+
+export class TsconfigGenerator implements IGenerator<CoreOptions> {
+  constructor(private readonly _fileService: IFileService) {}
+
+  public async generate(projectPath: string, options: CoreOptions): Promise<void> {
+    const tsconfig = {
+      compilerOptions: {
+        target: 'ES2022',
+        module: 'ESNext',
+        moduleResolution: 'bundler',
+        strict: true,
+        esModuleInterop: true,
+        skipLibCheck: true,
+        forceConsistentCasingInFileNames: true,
+        outDir: './dist',
+        rootDir: './src',
+        types: ['node'],
+        paths: {
+          '@/*': ['./src/*'],
+        },
+      },
+      include: ['src/**/*.ts'],
+    }
+
+    if (
+      options.database === CORE_CONSTANTS.DRIZZLE ||
+      options.database === CORE_CONSTANTS.SQL_LITE
+    ) {
+      tsconfig.include.push('drizzle.config.ts')
+    }
+
+    const filePath = path.join(projectPath, 'tsconfig.json')
+    await this._fileService.writeFileRecursive(filePath, JSON.stringify(tsconfig, null, 2))
+  }
+}

package/src/infrastructure/generators/gitignore.generator.ts

@@ -0,0 +1,60 @@
+import path from 'node:path'
+
+import type { IFileService, IGenerator } from '../../domain'
+import type { CoreOptions, ScaffoldingOptions } from '../../shared'
+import { CORE_CONSTANTS } from '../../shared'
+
+export class GitIgnoreGenerator implements IGenerator<ScaffoldingOptions> {
+  constructor(private readonly _fileService: IFileService) {}
+
+  public async generate(projectPath: string, options: ScaffoldingOptions): Promise<void> {
+    let content = `# Dependencies
+node_modules/
+
+# Build artifacts
+dist/
+out/
+build/
+
+# Environment variables
+# We ignore actual .env files for security, but keep .env.example for documentation
+.env
+.env.local
+.env.*
+!.env.example
+
+# Logs
+*.log
+logs/
+npm-debug.log*
+
+# Test coverage
+coverage/
+.nyc_output/
+
+# OS and IDE
+.DS_Store
+Thumbs.db
+.vscode/
+.idea/
+`
+
+    if ((options as CoreOptions).database === CORE_CONSTANTS.SQL_LITE) {
+      content += `\n# SQLite Database
+*.sqlite
+*.sqlite3
+*.sqlite-journal
+`
+    }
+
+    // Ignora la cartella di compilazione locale di Vercel se l'ambiente lo richiede
+    if ((options as CoreOptions).targetEnv === CORE_CONSTANTS.VERCEL) {
+      content += `\n# Vercel
+.vercel/
+`
+    }
+
+    const filePath = path.join(projectPath, '.gitignore')
+    await this._fileService.writeFileRecursive(filePath, content)
+  }
+}

package/src/infrastructure/generators/vue/app-vue.generator.ts

@@ -0,0 +1,21 @@
+import path from 'node:path'
+
+import { type IFileService, type IGenerator } from '../../../domain'
+import type { VueOptions } from '../../../shared'
+
+export class AppVueGenerator implements IGenerator<VueOptions> {
+  constructor(private readonly _fileService: IFileService) {}
+
+  public async generate(projectPath: string, options: VueOptions): Promise<void> {
+    // 2. src/App.vue
+    const appVue = `<script setup lang="ts">
+</script>
+
+<template>
+  <div id="xeno-app">
+    ${options.router ? '<router-view />' : '<h1>Welcome to Xeno Vue App</h1>'}
+  </div>
+</template>`
+    await this._fileService.writeFileRecursive(path.join(projectPath, 'src', 'App.vue'), appVue)
+  }
+}

package/src/infrastructure/generators/vue/bootstrap-ts.generator.ts

@@ -0,0 +1,60 @@
+import path from 'node:path'
+
+import { type IFileService, type IGenerator } from '../../../domain'
+import type { VueOptions } from '../../../shared'
+
+export class BootstrapGenerator implements IGenerator<VueOptions> {
+  constructor(private readonly _fileService: IFileService) {}
+
+  public async generate(projectPath: string, options: VueOptions): Promise<void> {
+    // 4. src/bootstrap.ts
+    let builderNodes = `  const builder = XenoAppBuilder.create<MyRegistry>()\n    .addContext(() => {})`
+
+    if (options.supabase) {
+      builderNodes += `\n    .addAuth((opts, config) => {
+      opts.url = config.getOrThrow('VITE_SUPABASE_URL');
+      opts.key = config.getOrThrow('VITE_SUPABASE_KEY');
+    })`
+    }
+
+    if (options.sentry) {
+      builderNodes += `\n    .addLogger((opts, config) => {
+      const env = config.get(COMMON_CONSTANTS.ENV) ?? 'development'
+      const isDev = env.toLowerCase() === 'development'
+      opts.console = isDev
+      if (!isDev) {
+        opts.sentry = {
+            dsn: config.getOrThrow('VITE_SENTRY_DSN'),
+            env,
+            app,
+            router,
+            tracesSampleRate: 0.2,
+            level: LOG_LEVEL.WARN,
+        };
+      }
+    })`
+    } else {
+      builderNodes += `\n    .addLogger((opts, config) => {
+      opts.console = config.get('VITE_APP_ENV') === 'development';
+    })`
+    }
+
+    builderNodes += `\n    .addServices((config, register) => {
+      // Register custom stores, API clients, and CQRS services here
+    })`
+
+    const bootstrapTs = `import { XenoAppBuilder, LOG_LEVEL } from '@xeno-js/vue';
+import type { MyRegistry } from './registry';
+
+export async function bootstrap(app: any, router: any) {
+${builderNodes}
+
+  return await builder.build();
+}
+`
+    await this._fileService.writeFileRecursive(
+      path.join(projectPath, 'src', 'bootstrap.ts'),
+      bootstrapTs,
+    )
+  }
+}

package/src/infrastructure/generators/vue/command_query/cqrs.generator.ts

@@ -0,0 +1,36 @@
+import path from 'node:path'
+
+import type { IFileService } from '../../../../domain'
+import { COMMAND_CONSTANTS, StringUtils } from '../../../../shared'
+
+export class CqrsVueGenerator {
+  constructor(private readonly _fileService: IFileService) {}
+
+  public async generate(
+    targetDir: string,
+    name: string,
+    type: 'command' | 'query',
+    outputPath?: string,
+  ): Promise<void> {
+    const pascalName = StringUtils.pascalCase(name)
+    const tokenPrefix = StringUtils.splitCamelCaseWithUnderscore(pascalName).toUpperCase()
+    const lowerName = name.toLowerCase()
+    const destinationFolder = outputPath ?? lowerName
+    const componentDir = path.join(targetDir, 'src', destinationFolder)
+
+    switch (type) {
+      case COMMAND_CONSTANTS.COMMAND: {
+        const { GenerateCommandVueGenerator } = await import('./generate-command-vue.generator.js')
+        const generator = new GenerateCommandVueGenerator(this._fileService)
+        return generator.generate(pascalName, lowerName, tokenPrefix, componentDir)
+      }
+      case COMMAND_CONSTANTS.QUERY: {
+        const { GenerateQueryVueGenerator } = await import('./generate-query-vue.generator.js')
+        const generatorQuery = new GenerateQueryVueGenerator(this._fileService)
+        return generatorQuery.generate(pascalName, lowerName, tokenPrefix, componentDir)
+      }
+      default:
+        throw new Error(`Unsupported generator type: '${String(type)}'. Use 'command' or 'query'.`)
+    }
+  }
+}

package/src/infrastructure/generators/vue/command_query/generate-command-vue.generator.ts

@@ -0,0 +1,153 @@
+import path from 'node:path'
+
+import type { IFileService } from '../../../../domain'
+
+export class GenerateCommandVueGenerator {
+  constructor(private readonly _fileService: IFileService) {}
+
+  public async generate(
+    pascalName: string,
+    lowerName: string,
+    tokenPrefix: string,
+    componentDir: string,
+  ): Promise<void> {
+    // 1. Command (Application)
+    const commandContent = `import { Command } from '@xeno-js/vue';
+
+export class ${pascalName}Command extends Command {
+    constructor() {
+        super('${tokenPrefix}_COMMAND');
+    }
+}
+`
+    await this._fileService.writeFileRecursive(
+      path.join(componentDir, `${lowerName}.command.ts`),
+      commandContent,
+    )
+
+    const handlerContent = `import type { IHandler, ResultType } from '@xeno-js/vue';
+import { AppError, Result } from '@xeno-js/vue';
+import type { ${pascalName}Command } from './${lowerName}.command';
+import type { ${pascalName}Response } from './${lowerName}.model';
+
+/*
+ * ⚠️ WARNING: ACTION REQUIRED ⚠️
+ * 
+ * Please register your handler in the IoC container (e.g. src/bootstrap.ts) and add its token to MyRegistry.
+ *
+ * 1. In src/registry.ts:
+ * ${tokenPrefix}_HANDLER: IHandler<${pascalName}Command, ${pascalName}Response>;
+ * 
+ * 2. In src/bootstrap.ts:
+ * .addServices((config, register) => {
+ *     register('${tokenPrefix}_HANDLER', new ${pascalName}Handler());
+ * });
+ */
+export class ${pascalName}Handler implements IHandler<${pascalName}Command, ${pascalName}Response> {
+    constructor(
+        // TODO: Inject your remote DataSources or other services here
+    ) {}
+
+    public async handle(command: ${pascalName}Command, signal: AbortSignal): Promise<ResultType<${pascalName}Response>> {
+        AppError.throwIfAborted(signal, this.constructor.name);
+
+        // TODO: Implement your frontend business logic or API calls here
+        return Result.ok();
+    }
+}
+`
+    await this._fileService.writeFileRecursive(
+      path.join(componentDir, `${lowerName}.handler.ts`),
+      handlerContent,
+    )
+
+    const composableContent = `import { ref } from 'vue';
+import { AppError, Result, type ApiResponseDto, type ResultType } from '@xeno-js/vue';
+import { ServicesUtils } from '@/use-app';
+import { ${pascalName}Command } from './${lowerName}.command';
+import type { ${pascalName}Request, ${pascalName}Response } from './${lowerName}.model';
+
+/*
+ * ⚠️ WARNING: ACTION REQUIRED ⚠️
+ *
+ * Please register your handler in the IoC container (e.g. src/bootstrap.ts) and add its token to MyRegistry.
+ *
+ * 1. In src/registry.ts:
+ * ${tokenPrefix}_HANDLER: IHandler<${pascalName}Command, ${pascalName}Response>;
+ * 
+ * 2. In src/bootstrap.ts:
+ * .addServices((config, register) => {
+ *     register('${tokenPrefix}_HANDLER', new ${pascalName}Handler());
+ * });
+ */
+export function use${pascalName}() {
+    const loading = ref(false);
+    const error = ref<string | null>(null);
+    let abortController: AbortController | null = null;
+
+    const execute = async (payload: ${pascalName}Request): Promise<ResultType<${pascalName}Response>> => {
+        abortController = new AbortController();
+        
+        if (loading.value) return Result.fail(AppError.create({
+            name: '${pascalName}Command',
+            message: '${pascalName}Command is already in progress',
+            code: '${tokenPrefix}_COMMAND_ALREADY_IN_PROGRESS',
+            status: 500,
+            cause: new Error('${tokenPrefix}_COMMAND_ALREADY_IN_PROGRESS'),
+        }));
+        loading.value = true;
+        error.value = null;
+
+        try {
+            // Resolve mediator and handler from the container
+            const { mediator, ${tokenPrefix}_HANDLER: handler } = ServicesUtils.useApp();
+            const command = new ${pascalName}Command();
+
+            const result = await mediator.send(command, async () => {
+                return await handler.handle(command, abortController?.signal);
+            });
+
+            if (!result.isOk()) {
+                error.value = result.getErrorOrThrow().message;
+            }
+
+            return result;
+        } finally {
+            loading.value = false;
+        }
+    };
+
+    const abort = () => {
+        if (abortController) {
+            abortController.abort();
+        }
+    };
+
+    // Automatically cancel pending operations when the component unmounts
+    onUnmounted(() => {
+        abort();
+    });
+
+    return { loading, error, execute };
+}
+`
+    await this._fileService.writeFileRecursive(
+      path.join(componentDir, `use-${lowerName}.composable.ts`),
+      composableContent,
+    )
+
+    // 3. Domain Model (Domain)
+    const modelContent = `export interface ${pascalName}Request {
+    // TODO: Define your request payload properties here
+}
+
+export interface ${pascalName}Response {
+    // TODO: Define your response properties here
+}
+`
+    await this._fileService.writeFileRecursive(
+      path.join(componentDir, `${lowerName}.model.ts`),
+      modelContent,
+    )
+  }
+}

package/src/infrastructure/generators/vue/command_query/generate-query-vue.generator.ts

@@ -0,0 +1,161 @@
+import path from 'node:path'
+
+import type { IFileService } from '../../../../domain'
+
+export class GenerateQueryVueGenerator {
+  constructor(private readonly _fileService: IFileService) {}
+
+  public async generate(
+    pascalName: string,
+    lowerName: string,
+    tokenPrefix: string,
+    componentDir: string,
+  ): Promise<void> {
+    // 1. Query (Application)
+    const queryContent = `import { Query } from '@xeno-js/vue';
+import type { ${pascalName}Response } from './${lowerName}.model';
+
+export class ${pascalName}Query extends Query<${pascalName}Response> {
+    constructor() {
+        super('${tokenPrefix}_QUERY', {
+            ttl: 60,
+            cacheKey: \`${lowerName}.query\`,
+            bypassCache: false,
+            consistentRead: false,
+            isUserScoped: true
+        });
+    }
+}
+`
+    await this._fileService.writeFileRecursive(
+      path.join(componentDir, `${lowerName}.query.ts`),
+      queryContent,
+    )
+
+    const handlerContent = `import type { IHandler, ResultType } from '@xeno-js/vue';
+import { AppError, Result } from '@xeno-js/vue';
+import type { ${pascalName}Query } from './${lowerName}.query';
+import type { ${pascalName}Response } from './${lowerName}.model';
+
+    /*
+ * ⚠️ WARNING: ACTION REQUIRED ⚠️
+ *
+ * Please register your handler in the IoC container (e.g. src/bootstrap.ts) and add its token to MyRegistry.
+ *
+ * 1. In src/registry.ts:
+ * ${tokenPrefix}_HANDLER: IHandler<${pascalName}Query, ${pascalName}Response>;
+ * 
+ * 2. In src/bootstrap.ts:
+ * .addServices((config, register) => {
+ *     register('${tokenPrefix}_HANDLER', new ${pascalName}Handler());
+ * });
+ */
+export class ${pascalName}Handler implements IHandler<${pascalName}Query, ${pascalName}Response> {
+    constructor(
+        // TODO: Inject your remote DataSources or other services here
+    ) {}
+
+    public async handle(query: ${pascalName}Query, signal: AbortSignal): Promise<ResultType<${pascalName}Response>> {
+        AppError.throwIfAborted(signal, this.constructor.name);
+
+        // TODO: Implement your frontend business logic or API calls here
+        return Result.ok();
+    }
+}
+`
+    await this._fileService.writeFileRecursive(
+      path.join(componentDir, `${lowerName}.handler.ts`),
+      handlerContent,
+    )
+
+    // 2. Composable (Presentation)
+    const composableContent = `import { ref } from 'vue';
+import { AppError, Result, type ApiResponseDto, type ResultType } from '@xeno-js/vue';
+import { ServicesUtils } from '@/use-app';
+import { ${pascalName}Query } from './${lowerName}.query';
+import type { ${pascalName}Response } from './${lowerName}.model';
+
+export function use${pascalName}() {
+    const loading = ref(false);
+    const error = ref<string | null>(null);
+    const data = ref<${pascalName}Response | null>(null);
+    let abortController: AbortController | null = null;
+
+    /*
+ * ⚠️ WARNING: ACTION REQUIRED ⚠️
+ *
+ * Please register your handler in the IoC container (e.g. src/bootstrap.ts) and add its token to MyRegistry.
+ *
+ * 1. In src/registry.ts:
+ * ${tokenPrefix}_HANDLER: IHandler<${pascalName}Query, ${pascalName}Response>;
+ * 
+ * 2. In src/bootstrap.ts:
+ * .addServices((config, register) => {
+ *     register('${tokenPrefix}_HANDLER', new ${pascalName}Handler());
+ * });
+ */
+const fetch = async (): Promise<ResultType<${pascalName}Response>> => {
+        abortController = new AbortController();
+
+        if (loading.value) return Result.fail(AppError.create({
+            name: '${pascalName}Query',
+            message: '${pascalName}Query is already in progress',
+            code: '${tokenPrefix}_QUERY_ALREADY_IN_PROGRESS',
+            status: 500,
+            cause: new Error('${tokenPrefix}_QUERY_ALREADY_IN_PROGRESS'),
+        }));
+        loading.value = true;
+        error.value = null;
+
+        try {
+            try {
+            // Resolve mediator and handler from the container
+            const { mediator, ${tokenPrefix}_HANDLER: handler } = ServicesUtils.useApp();
+            const query = new ${pascalName}Query();
+
+            const result = await mediator.query(query, async () => {
+                return await handler.handle(query, abortController?.signal);
+            });
+
+            if (result.isOk()) {
+                data.value = result.getValueOrThrow();
+            } else {
+                error.value = result.getErrorOrThrow().message;
+            }
+
+            return result;
+        } finally {
+            loading.value = false;
+        }
+    };
+
+    const abort = () => {
+        if (abortController) {
+            abortController.abort();
+        }
+    };
+
+    // Automatically cancel pending operations when the component unmounts
+    onUnmounted(() => {
+        abort();
+    });
+
+    return { loading, error, data, fetch };
+}
+`
+    await this._fileService.writeFileRecursive(
+      path.join(componentDir, `use-${lowerName}.composable.ts`),
+      composableContent,
+    )
+
+    // 3. Domain Model (Domain)
+    const modelContent = `export interface ${pascalName}Response {
+    // TODO: Define your response properties here
+}
+`
+    await this._fileService.writeFileRecursive(
+      path.join(componentDir, `${lowerName}.model.ts`),
+      modelContent,
+    )
+  }
+}

package/src/infrastructure/generators/vue/env.generator.ts

@@ -0,0 +1,39 @@
+// src/infrastructure/generators/env-vue.generator.ts
+import path from 'node:path'
+
+import { type IFileService, type IGenerator } from '../../../domain'
+import type { VueOptions } from '../../../shared'
+
+export class EnvVueGenerator implements IGenerator<VueOptions> {
+  constructor(private readonly _fileService: IFileService) {}
+
+  public async generate(projectPath: string, options: VueOptions): Promise<void> {
+    let content = `# ─────────────────────────────────────────────────────────────────────────────
+# Xeno VUE APPLICATION ENVIRONMENT VARIABLES
+# ─────────────────────────────────────────────────────────────────────────────
+VITE_APP_ENV=development
+`
+
+    if (options.axios) {
+      content += `\n# --- Axios ---
+VITE_API_BASE_URL=http://localhost:3000
+`
+    }
+
+    if (options.supabase) {
+      content += `\n# --- Authentication (Supabase) ---
+VITE_SUPABASE_URL=https://your-project.supabase.co
+VITE_SUPABASE_KEY=your-anon-key
+`
+    }
+
+    if (options.sentry) {
+      content += `\n# --- Error Tracking (Sentry) ---
+VITE_SENTRY_DSN=https://your-sentry-dsn@o0.ingest.sentry.io/0
+`
+    }
+
+    await this._fileService.writeFileRecursive(path.join(projectPath, '.env'), content)
+    await this._fileService.writeFileRecursive(path.join(projectPath, '.env.example'), content)
+  }
+}

package/src/infrastructure/generators/vue/index-html.generator.ts

@@ -0,0 +1,24 @@
+import path from 'node:path'
+
+import { type IFileService, type IGenerator } from '../../../domain'
+import type { VueOptions } from '../../../shared'
+
+export class IndexVueGenerator implements IGenerator<VueOptions> {
+  constructor(private readonly _fileService: IFileService) {}
+
+  public async generate(projectPath: string, options: VueOptions): Promise<void> {
+    const indexHtml = `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${options.targetDir}</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>`
+    await this._fileService.writeFileRecursive(path.join(projectPath, 'index.html'), indexHtml)
+  }
+}

package/src/infrastructure/generators/vue/index.ts

@@ -0,0 +1,12 @@
+export * from './app-vue.generator'
+export * from './bootstrap-ts.generator'
+export * from './env.generator'
+export * from './index-html.generator'
+export * from './main.generator'
+export * from './packagejson.generator'
+export * from './readme.generator'
+export * from './registry-ts.generator'
+export * from './router.generator'
+export * from './tailwind.generator'
+export * from './tsconfig.generator'
+export * from './vite-config.generator'

package/src/infrastructure/generators/vue/main.generator.ts

@@ -0,0 +1,41 @@
+import path from 'node:path'
+
+import { type IFileService, type IGenerator } from '../../../domain'
+import type { VueOptions } from '../../../shared'
+
+export class MainGenerator implements IGenerator<VueOptions> {
+  constructor(private readonly _fileService: IFileService) {}
+
+  public async generate(projectPath: string, options: VueOptions): Promise<void> {
+    // 5. src/main.ts
+    const routerImport = options.router ? `\nimport router from './router';` : ''
+    const piniaImport = options.pinia ? `\nimport { createPinia } from 'pinia';` : ''
+    const tailwindImport = options.tailwind ? `\nimport './assets/style.css';` : ''
+
+    const mainTs = `import { createApp } from 'vue';
+import App from './App.vue';
+import { bootstrap } from './bootstrap';
+import { XENO_SERVICES_KEY } from '@xeno-js/vue';${routerImport}${piniaImport}${tailwindImport}
+
+async function mountApp() {
+  try {
+    const app = createApp(App);
+    ${options.pinia ? '\n    app.use(createPinia());' : ''}
+    const container = await bootstrap(app, router);
+    ${options.router ? '\n    app.use(router);' : ''}
+    
+
+    // Provide the Xeno IoC container globally to all components
+    app.provide(XENO_SERVICES_KEY, container);
+
+    app.mount('#app');
+  } catch (error) {
+    console.error('Critical error during frontend bootstrap:', error);
+  }
+}
+
+mountApp();
+`
+    await this._fileService.writeFileRecursive(path.join(projectPath, 'src', 'main.ts'), mainTs)
+  }
+}