@quatrain/app 1.1.1

package/dist/InfraBuilder.js

@@ -0,0 +1,132 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InfraBuilder = void 0;
+const yaml = __importStar(require("yaml"));
+class InfraBuilder {
+    static build(config, appName = 'quatrain-app') {
+        const compose = {
+            services: {},
+            volumes: {}
+        };
+        const envVars = {};
+        compose.services['engine'] = {
+            build: {
+                context: '.',
+                dockerfile: 'Containerfile'
+            },
+            container_name: `${appName}-engine`,
+            restart: 'unless-stopped',
+            ports: ['3000:3000', '4001:4000'],
+            environment: {
+                NODE_ENV: 'production'
+            },
+            volumes: ['./quatrain.json:/app/quatrain.json:ro'],
+            depends_on: []
+        };
+        if (config.backend && config.backend.adapter === 'PostgresAdapter') {
+            const dbUser = 'quatrain';
+            const dbPass = 'quatrain_pass';
+            const dbName = 'quatrain_db';
+            compose.services['postgres'] = {
+                image: 'postgres:15-alpine',
+                container_name: `${appName}-postgres`,
+                restart: 'unless-stopped',
+                ports: ['5432:5432'],
+                environment: {
+                    POSTGRES_USER: dbUser,
+                    POSTGRES_PASSWORD: dbPass,
+                    POSTGRES_DB: dbName
+                },
+                volumes: ['postgres_data:/var/lib/postgresql/data']
+            };
+            compose.volumes['postgres_data'] = {};
+            compose.services['engine'].depends_on.push('postgres');
+            envVars['DATABASE_URL'] = `postgresql://${dbUser}:${dbPass}@postgres:5432/${dbName}`;
+        }
+        if (config.storage && config.storage.adapter === 'S3Adapter') {
+            const s3User = 'minioadmin';
+            const s3Pass = 'minioadminpassword';
+            compose.services['minio'] = {
+                image: 'minio/minio:latest',
+                container_name: `${appName}-minio`,
+                restart: 'unless-stopped',
+                ports: ['9000:9000', '9001:9001'],
+                environment: {
+                    MINIO_ROOT_USER: s3User,
+                    MINIO_ROOT_PASSWORD: s3Pass
+                },
+                command: 'server /data --console-address ":9001"',
+                volumes: ['minio_data:/data']
+            };
+            compose.volumes['minio_data'] = {};
+            compose.services['engine'].depends_on.push('minio');
+            envVars['S3_ENDPOINT'] = `http://minio:9000`;
+            envVars['S3_ACCESS_KEY'] = s3User;
+            envVars['S3_SECRET_KEY'] = s3Pass;
+        }
+        if (config.queue && config.queue.adapter === 'AmqpAdapter') {
+            compose.services['rabbitmq'] = {
+                image: 'rabbitmq:3-management-alpine',
+                container_name: `${appName}-rabbitmq`,
+                restart: 'unless-stopped',
+                ports: ['5672:5672', '15672:15672']
+            };
+            compose.services['engine'].depends_on.push('rabbitmq');
+            envVars['AMQP_URL'] = `amqp://rabbitmq:5672`;
+        }
+        if (compose.services['engine'].depends_on?.length === 0) {
+            delete compose.services['engine'].depends_on;
+        }
+        if (Object.keys(compose.volumes).length === 0) {
+            delete compose.volumes;
+        }
+        const composeYaml = yaml.stringify(compose);
+        const envFile = Object.entries(envVars).map(([k, v]) => `${k}=${v}`).join('\n');
+        const dockerfile = `
+FROM oven/bun:latest
+WORKDIR /app
+COPY package.json tsconfig.json quatrain.json ./
+RUN bun install
+COPY src ./src
+COPY data ./data
+EXPOSE 3000 4001
+CMD ["bun", "run", "src/index.ts"]
+      `.trim();
+        return { compose: composeYaml, env: envFile, dockerfile };
+    }
+}
+exports.InfraBuilder = InfraBuilder;
+//# sourceMappingURL=InfraBuilder.js.map

package/dist/InfraBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InfraBuilder.js","sourceRoot":"","sources":["../src/InfraBuilder.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './Bootloader';
+export * from './Infra';
+export * from './InfraBuilder';
+export * from './CodeGenerator';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,SAAS,CAAA;AACvB,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA"}

package/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Bootloader"), exports);
+__exportStar(require("./Infra"), exports);
+__exportStar(require("./InfraBuilder"), exports);
+__exportStar(require("./CodeGenerator"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,+CAA4B;AAC5B,0CAAuB;AACvB,iDAA8B;AAC9B,kDAA+B"}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@quatrain/app",
+  "version": "1.1.1",
+  "license": "AGPL-3.0-only",
+  "description": "Quatrain App Bootloader and configuration helpers",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bun": "src/index.ts",
+  "files": [
+    "LICENSE.md",
+    "src/",
+    "dist/",
+    "README.md",
+    "NOTICE.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Quatrain/Core.git",
+    "directory": "packages/app"
+  },
+  "author": "Quatrain Développement SAS <developers@quatrain.com>",
+  "dependencies": {
+    "@quatrain/auth": "^1.2.0",
+    "@quatrain/backend": "^1.2.0",
+    "@quatrain/core": "^1.2.0",
+    "@quatrain/log": "^1.2.0",
+    "@quatrain/messaging": "^1.1.0",
+    "@quatrain/queue": "^1.2.0",
+    "@quatrain/storage": "^1.2.0",
+    "yaml": "^2.4.0"
+  },
+  "devDependencies": {
+    "@tsconfig/recommended": "^1.0.1",
+    "@types/node": "^22.10.1",
+    "typescript": "^5.2.2"
+  },
+  "scripts": {
+    "build": "tsc",
+    "wbuild": "tsc --watch"
+  }
+}

package/src/Bootloader.ts

@@ -0,0 +1,121 @@
+import fs from 'fs'
+import path from 'path'
+import { Core } from '@quatrain/core'
+import { Log, LogLevel } from '@quatrain/log'
+
+// Global singletons from Quatrain
+import { Backend } from '@quatrain/backend'
+import { Auth } from '@quatrain/auth'
+import { Queue } from '@quatrain/queue'
+import { Storage } from '@quatrain/storage'
+import { Messaging } from '@quatrain/messaging'
+
+export class AppBootloader {
+   /**
+    * Remplace récursivement toutes les chaînes 'env(NAME)' par la variable d'environnement correspondante.
+    */
+   private static resolveEnv(obj: any): any {
+      if (typeof obj === 'string') {
+         const match = obj.match(/^env\(([^)]+)\)$/)
+         if (match) {
+            return process.env[match[1]] || ''
+         }
+         return obj
+      } else if (Array.isArray(obj)) {
+         return obj.map(item => this.resolveEnv(item))
+      } else if (obj !== null && typeof obj === 'object') {
+         const resolved: any = {}
+         for (const key of Object.keys(obj)) {
+            resolved[key] = this.resolveEnv(obj[key])
+         }
+         return resolved
+      }
+      return obj
+   }
+
+   /**
+    * Charge la configuration JSON et initialise tous les Adapters.
+    */
+   public static async bootstrap(configPath: string = 'quatrain.json'): Promise<void> {
+      const fullPath = path.resolve(process.cwd(), configPath)
+      
+      if (!fs.existsSync(fullPath)) {
+         throw new Error(`[Bootloader] Configuration file not found at: ${fullPath}`)
+      }
+
+      const rawConfig = JSON.parse(fs.readFileSync(fullPath, 'utf8'))
+      const config = this.resolveEnv(rawConfig)
+
+      Log.info(`[Bootloader] Initializing application from ${configPath}`)
+
+      // Set global log level if provided
+      if (config.logLevel) {
+         const level = (LogLevel as any)[config.logLevel.toUpperCase()]
+         if (level !== undefined) {
+            Core.setLogLevel(level)
+         }
+      }
+
+      // --- Initialize Backend ---
+      if (config.backend && config.backend.package && config.backend.adapter) {
+         Log.info(`[Bootloader] Loading Backend Adapter: ${config.backend.adapter}`)
+         try {
+            const pkg = require(config.backend.package)
+            const AdapterClass = pkg[config.backend.adapter]
+            Backend.addBackend(new AdapterClass({ config: config.backend.config || {} }), 'default', true)
+         } catch (e: any) {
+            Log.error(`[Bootloader] Failed to load backend: ${e.message}`)
+         }
+      }
+
+      // --- Initialize Auth ---
+      if (config.auth && config.auth.package && config.auth.adapter) {
+         Log.info(`[Bootloader] Loading Auth Adapter: ${config.auth.adapter}`)
+         try {
+            const pkg = require(config.auth.package)
+            const AdapterClass = pkg[config.auth.adapter]
+            Auth.addProvider(new AdapterClass({ config: config.auth.config || {} }), 'default', true)
+         } catch (e: any) {
+            Log.error(`[Bootloader] Failed to load auth: ${e.message}`)
+         }
+      }
+
+      // --- Initialize Queue ---
+      if (config.queue && config.queue.package && config.queue.adapter) {
+         Log.info(`[Bootloader] Loading Queue Adapter: ${config.queue.adapter}`)
+         try {
+            const pkg = require(config.queue.package)
+            const AdapterClass = pkg[config.queue.adapter]
+            Queue.addQueue(new AdapterClass({ config: config.queue.config || {} }), 'default', true)
+         } catch (e: any) {
+            Log.error(`[Bootloader] Failed to load queue: ${e.message}`)
+         }
+      }
+
+      // --- Initialize Storage ---
+      if (config.storage && config.storage.package && config.storage.adapter) {
+         Log.info(`[Bootloader] Loading Storage Adapter: ${config.storage.adapter}`)
+         try {
+            const pkg = require(config.storage.package)
+            const AdapterClass = pkg[config.storage.adapter]
+            Storage.addStorage(new AdapterClass({ config: config.storage.config || {} }), 'default', true)
+         } catch (e: any) {
+            Log.error(`[Bootloader] Failed to load storage: ${e.message}`)
+         }
+      }
+
+      // --- Initialize Messaging ---
+      if (config.messaging && config.messaging.package && config.messaging.adapter) {
+         Log.info(`[Bootloader] Loading Messaging Adapter: ${config.messaging.adapter}`)
+         try {
+            const pkg = require(config.messaging.package)
+            const AdapterClass = pkg[config.messaging.adapter]
+            Messaging.addMessager(new AdapterClass({ config: config.messaging.config || {} }), 'default', true)
+         } catch (e: any) {
+            Log.error(`[Bootloader] Failed to load messaging: ${e.message}`)
+         }
+      }
+
+      Log.info(`[Bootloader] Bootstrap completed successfully.`)
+   }
+}

package/src/CodeGenerator.ts

@@ -0,0 +1,246 @@
+import * as fs from 'fs'
+import * as path from 'path'
+import { Log } from '@quatrain/log'
+
+export class CodeGenerator {
+   /**
+    * Génère une application complète dans le dossier cible
+    */
+   public static generate(config: any, targetDir: string): void {
+      const fullTargetDir = path.resolve(process.cwd(), targetDir)
+      
+      // Ensure base directories exist
+      const dirs = ['src/models', 'src/api', 'data/migrations/default']
+      for (const dir of dirs) {
+         const d = path.resolve(fullTargetDir, dir)
+         if (!fs.existsSync(d)) {
+            fs.mkdirSync(d, { recursive: true })
+         }
+      }
+
+      this.generatePackageJson(config, fullTargetDir)
+      this.generateTsConfig(fullTargetDir)
+      
+      const generatedModels = this.generateModels(config, fullTargetDir)
+      this.generateApiEndpoints(config, fullTargetDir, generatedModels)
+      this.generateIndex(config, fullTargetDir, generatedModels)
+      this.generateMigration(config, fullTargetDir)
+
+      Log.info(`[CodeGenerator] Application générée avec succès dans ${fullTargetDir}`)
+   }
+
+   private static generatePackageJson(config: any, targetDir: string): void {
+      const packagePath = path.resolve(targetDir, 'package.json')
+      
+      const targetNpmTag = 'latest-dev' // Use 'latest' for production, 'latest-dev' for testing features
+
+      const packageJson = {
+         name: config.name?.toLowerCase().replace(/[^a-z0-9]/g, '-') || "quatrain-generated-app",
+         version: "1.0.0",
+         description: "Generated by Quatrain Studio",
+         main: "src/index.ts",
+         type: "module",
+         scripts: {
+            start: "bun run src/index.ts"
+         },
+         dependencies: {
+            "@quatrain/core": targetNpmTag,
+            "@quatrain/backend": targetNpmTag,
+            "@quatrain/backend-sqlite": targetNpmTag,
+            "@quatrain/api": targetNpmTag,
+            "@quatrain/api-server": targetNpmTag,
+            "@quatrain/backend-migrations": targetNpmTag
+         } as Record<string, string>
+      }
+
+      if (config.authMode === 'oauth') {
+         packageJson.dependencies['@quatrain/auth-oidc'] = targetNpmTag
+      }
+      
+      if (config.backend?.adapter === 'PostgresAdapter') {
+         packageJson.dependencies['@quatrain/backend-postgres'] = targetNpmTag
+      }
+
+      Log.info(`[CodeGenerator] Generating package.json with dependencies`)
+      fs.writeFileSync(packagePath, JSON.stringify(packageJson, null, 2))
+   }
+
+   private static generateTsConfig(targetDir: string): void {
+      const tsconfig = {
+         compilerOptions: {
+            target: "ES2022",
+            module: "ESNext",
+            moduleResolution: "node",
+            esModuleInterop: true,
+            strict: true,
+            skipLibCheck: true,
+            forceConsistentCasingInFileNames: true,
+            outDir: "dist"
+         },
+         include: ["src/**/*", "data/migrations/**/*"]
+      }
+      fs.writeFileSync(path.resolve(targetDir, 'tsconfig.json'), JSON.stringify(tsconfig, null, 2))
+   }
+
+   private static generateModels(config: any, targetDir: string): string[] {
+      const models = config.models || []
+      const generatedNames: string[] = []
+
+      for (const model of models) {
+         if (!model.name) continue
+         const className = model.name
+         const collectionName = model.collectionName || className.toLowerCase()
+         generatedNames.push(className)
+
+         // Use imports from core properties
+         const propsCode = model.properties.map((p: any) => {
+            const propType = p.type // e.g. "StringProperty"
+            return `   {
+      name: '${p.name}',
+      type: ${propType}.TYPE,
+      mandatory: ${p.options?.mandatory ? 'true' : 'false'}
+   }`
+         }).join(',\n')
+
+         const propTypesToImport = Array.from(new Set(model.properties.map((p: any) => p.type)))
+         
+         const modelCode = `import { PersistedBaseObject } from '@quatrain/backend'
+import { ${propTypesToImport.join(', ')} } from '@quatrain/core'
+
+export const ${className}Properties = [
+${propsCode}
+]
+
+export class ${className} extends PersistedBaseObject {
+   static PROPS_DEFINITION = ${className}Properties
+   static COLLECTION = '${collectionName}'
+
+   static async factory(src: any = undefined): Promise<${className}> {
+      return super.factory(src, ${className})
+   }
+}
+`
+         fs.writeFileSync(path.resolve(targetDir, `src/models/${className}.ts`), modelCode)
+      }
+
+      return generatedNames
+   }
+
+   private static generateApiEndpoints(config: any, targetDir: string, models: string[]): void {
+      for (const className of models) {
+         const apiCode = `import { CrudEndpoint } from '@quatrain/api-server'
+import { ${className} } from '../models/${className}'
+
+export class ${className}Api extends CrudEndpoint {
+   constructor() {
+      super('/api/${className.toLowerCase()}s', ${className})
+   }
+}
+`
+         fs.writeFileSync(path.resolve(targetDir, `src/api/${className}Api.ts`), apiCode)
+      }
+   }
+
+   private static generateIndex(config: any, targetDir: string, models: string[]): void {
+      const adapterClass = config.backend?.adapter === 'PostgresAdapter' ? 'PostgresAdapter' : 'SQLiteAdapter'
+      const adapterImport = config.backend?.adapter === 'PostgresAdapter' ? '@quatrain/backend-postgres' : '@quatrain/backend-sqlite'
+      
+      const modelImports = models.map(m => `import { ${m} } from './models/${m}'`).join('\n')
+      const apiImports = models.map(m => `import { ${m}Api } from './api/${m}Api'`).join('\n')
+      const apiRegisters = models.map(m => `      server.addEndpoint(new ${m}Api())`).join('\n')
+
+      const indexCode = `import * as path from 'path'
+import { Backend, InjectMetaMiddleware } from '@quatrain/backend'
+import { ${adapterClass} } from '${adapterImport}'
+import { ExpressAdapter } from '@quatrain/api-server'
+import { MigrationManager } from '@quatrain/backend-migrations'
+${config.authMode === 'oauth' ? `import { AuthOIDC } from '@quatrain/auth-oidc'\n` : ''}
+${modelImports}
+${apiImports}
+
+;(async () => {
+   try {
+      const adapter = new ${adapterClass}({ 
+         config: ${adapterClass === 'SQLiteAdapter' ? '{ database: path.resolve(process.cwd(), "data/app.sqlite") }' : 'process.env.DATABASE_URL'},
+         middlewares: [new InjectMetaMiddleware()]
+      })
+
+      Backend.init(adapter)
+      
+      const mm = new MigrationManager()
+      await mm.up()
+      
+      const server = new ExpressAdapter()
+      
+${apiRegisters}
+
+${config.authMode === 'oauth' ? `      // Initialize OIDC Auth
+      const oidc = AuthOIDC.init('http://localhost:4001')
+      server.getApp().use('/oidc', oidc.callback())
+` : ''}
+
+      const PORT = Number(process.env.PORT) || 4001
+      server.start(PORT, () => {
+         console.log(\`🚀 Server started on port \${PORT}\`)
+      })
+   } catch (e) {
+      console.error(e)
+      process.exit(1)
+   }
+})()
+`
+      fs.writeFileSync(path.resolve(targetDir, 'src/index.ts'), indexCode)
+   }
+
+   private static generateMigration(config: any, targetDir: string): void {
+      const models = config.models || []
+      
+      let upQueries = ''
+      let downQueries = ''
+
+      for (const model of models) {
+         if (!model.name) continue
+         const collectionName = model.collectionName || model.name.toLowerCase()
+         
+         const columns = model.properties.map((p: any) => {
+            // Very simplified SQLite type mapping for the PoC
+            let sqlType = 'TEXT'
+            if (p.type === 'NumberProperty' || p.type === 'BooleanProperty') sqlType = 'INTEGER'
+            return `${p.name} ${sqlType}`
+         }).join(',\n         ')
+
+         upQueries += `
+      await adapter.rawQuery(\`CREATE TABLE IF NOT EXISTS ${collectionName} (
+         id TEXT PRIMARY KEY,
+         status TEXT,
+         created_at TEXT,
+         updated_at TEXT,
+         created_by TEXT,
+         updated_by TEXT,
+         ${columns}
+      )\`)\n`
+
+         downQueries += `
+      await adapter.rawQuery('DROP TABLE IF EXISTS ${collectionName}')\n`
+      }
+
+      const migrationCode = `import { AbstractBackendAdapter } from '@quatrain/backend'
+
+export const up = async ({ context: adapter }: { context: AbstractBackendAdapter }) => {
+   try {${upQueries}
+   } catch (e) {
+      console.error('Migration up error', e)
+   }
+}
+
+export const down = async ({ context: adapter }: { context: AbstractBackendAdapter }) => {
+   try {${downQueries}
+   } catch (e) {
+      console.error('Migration down error', e)
+   }
+}
+`
+      const timestamp = new Date().toISOString().replace(/[-:T]/g, '').slice(0, 14)
+      fs.writeFileSync(path.resolve(targetDir, `data/migrations/default/${timestamp}_init.ts`), migrationCode)
+   }
+}

package/src/Infra.ts

@@ -0,0 +1,96 @@
+import { exec } from 'child_process'
+import path from 'path'
+import { Log } from '@quatrain/log'
+import fs from 'fs'
+import { InfraBuilder } from './InfraBuilder'
+import { CodeGenerator } from './CodeGenerator'
+
+export class AppInfra {
+   /**
+    * Démarrer l'infrastructure locale (bases de données, storages, brokers)
+    * via podman-compose ou docker-compose
+    * Si une configuration est fournie, génère d'abord les fichiers compose.yaml et .env dans le dossier app/
+    */
+   public static async start(config?: any, targetDir: string = 'app'): Promise<void> {
+      let composeFile = path.resolve(process.cwd(), targetDir, 'compose.yaml')
+
+      if (config) {
+         // Générer dynamiquement les fichiers de déploiement
+         const fullTargetDir = path.resolve(process.cwd(), targetDir)
+         if (!fs.existsSync(fullTargetDir)) {
+            fs.mkdirSync(fullTargetDir, { recursive: true })
+         }
+
+         // Generate Application Source Code
+         CodeGenerator.generate(config, targetDir)
+
+         // Generate Infrastructure configuration
+         const { compose, env, dockerfile } = InfraBuilder.build(config)
+         
+         fs.writeFileSync(composeFile, compose, 'utf8')
+         fs.writeFileSync(path.resolve(fullTargetDir, '.env'), env, 'utf8')
+         fs.writeFileSync(path.resolve(fullTargetDir, 'Containerfile'), dockerfile, 'utf8')
+         
+         Log.info(`[Infra] Dynamically generated compose.yaml and .env in ${fullTargetDir}`)
+      }
+
+      return this.runCompose('up -d --build', composeFile)
+   }
+
+   /**
+    * Arrêter l'infrastructure locale
+    */
+   public static async stop(targetDir: string = 'app'): Promise<void> {
+      const composeFile = path.resolve(process.cwd(), targetDir, 'compose.yaml')
+      return this.runCompose('down', composeFile)
+   }
+
+   private static getComposeCommand(): string {
+      // Prioritize podman compose if working 'modern', otherwise fallback to docker compose
+      return 'podman compose'
+   }
+
+   private static async runCompose(action: string, composeFile: string): Promise<void> {
+      return new Promise((resolve, reject) => {
+         if (!fs.existsSync(composeFile)) {
+            Log.error(`[Infra] Compose file not found at: ${composeFile}`)
+            return reject(new Error(`Compose file not found: ${composeFile}`))
+         }
+
+         const cmd = `${this.getComposeCommand()} -f ${composeFile} ${action}`
+         Log.info(`[Infra] Executing: ${cmd}`)
+
+         const child = exec(cmd, (error, stdout, stderr) => {
+            if (error) {
+               // Fallback to docker-compose if podman-compose is not installed
+               if (error.message.includes('command not found')) {
+                  Log.warn(`[Infra] podman compose not found, falling back to docker compose...`)
+                  exec(`docker compose -f ${composeFile} ${action}`, (err2, out2, errOut2) => {
+                     if (err2) {
+                        Log.error(`[Infra] Failed to run infrastructure: ${err2.message}`)
+                        return reject(err2)
+                     }
+                     if (out2) Log.debug(`[Infra] ${out2}`)
+                     if (errOut2) Log.debug(`[Infra] ${errOut2}`)
+                     resolve()
+                  })
+                  return
+               }
+               Log.error(`[Infra] Failed to run infrastructure: ${error.message}`)
+               return reject(error)
+            }
+            if (stdout) Log.debug(`[Infra] ${stdout}`)
+            if (stderr) Log.debug(`[Infra] ${stderr}`)
+            resolve()
+         })
+
+         // Stream output to console
+         if (child.stdout) {
+            child.stdout.on('data', (data) => console.log(data.toString().trim()))
+         }
+         if (child.stderr) {
+            child.stderr.on('data', (data) => console.error(data.toString().trim()))
+         }
+      })
+   }
+}