simple-boot

import 'reflect-metadata';
import { SimpleApplication } from '@dooboostore/simple-boot/SimpleApplication';
import { Sim } from '@dooboostore/simple-boot/decorators/SimDecorator';

// Define a service
@Sim
class HelloService {
  greet(name: string) {
    return `Hello, ${name}!`;
  }
}

// Create and run application
const app = new SimpleApplication().run();

// Get service instance
const helloService = app.sim(HelloService);
console.log(helloService.greet('World')); // "Hello, World!"

import { Sim } from '@dooboostore/simple-boot/decorators/SimDecorator';
import { SimpleApplication } from '@dooboostore/simple-boot/SimpleApplication';

// Singleton service
@Sim
class UserService {
  private users: Map<string, any></string,>= new Map();

  constructor() &#123;
    console.log('[UserService] Created (only once)');
  &#125;

  addUser(id: string, name: string) &#123;
    this.users.set(id, &#123; id, name &#125;);
    console.log(`Added user: &#36;&#123;name&#125;`);
  &#125;

  getUser(id: string) &#123;
    return this.users.get(id);
  &#125;

  getAllUsers() &#123;
    return Array.from(this.users.values());
  &#125;
&#125;

// Usage
const app = new SimpleApplication().run();

// Get instances
const service1 = app.sim(UserService);
const service2 = app.sim(UserService);

console.log(service1 === service2); // true - Same instance!

service1.addUser('user1', 'Alice');
service2.addUser('user2', 'Bob');

console.log(service1.getAllUsers()); // [&#123; id: 'user1', name: 'Alice' &#125;, &#123; id: 'user2', name: 'Bob' &#125;]
console.log(service2.getAllUsers()); // Same array - shared state!

import { Sim, Lifecycle } from '@dooboostore/simple-boot/decorators/SimDecorator';

// Transient service - new instance each time
@Sim({ scope: Lifecycle.Transient })
class RequestLogger {
  private requestId: string;

  constructor() {
    this.requestId = `req-${Math.random().toString(36).substring(7)}`;
    console.log(`[RequestLogger] Created with ID: ${this.requestId}`);
  }

  logRequest(method: string, path: string) {
    console.log(`[${this.requestId}] ${method} ${path}`);
  }

  getRequestId() {
    return this.requestId;
  }
}

// Usage
const app = new SimpleApplication().run();

const logger1 = app.sim(RequestLogger); // Creates new instance
const logger2 = app.sim(RequestLogger); // Creates another new instance

console.log(logger1 === logger2); // false - Different instances!
console.log(logger1.getRequestId()); // "req-abc123"
console.log(logger2.getRequestId()); // "req-xyz789"

logger1.logRequest('GET', '/users');    // [req-abc123] GET /users
logger2.logRequest('POST', '/orders');  // [req-xyz789] POST /orders

import { Sim } from '@dooboostore/simple-boot/decorators/SimDecorator';

@Sim
class UserService {
  getUser(userId: string) {
    return { id: userId, name: `User ${userId}`, email: `user${userId}@example.com` };
  }
}

// NotificationService automatically gets UserService injected
@Sim
class NotificationService {
  constructor(private userService: UserService) {
    console.log('[NotificationService] Created with injected UserService');
  }

  notifyUser(userId: string, message: string) {
    const user = this.userService.getUser(userId);
    if (user) {
      console.log(`📧 Sending notification to ${user.name}: "${message}"`);
      return true;
    }
    console.log(`⚠️  User ${userId} not found`);
    return false;
  }
}

// Usage
const app = new SimpleApplication().run();

// UserService is automatically created and injected
const notificationService = app.sim(NotificationService);
notificationService.notifyUser('user1', 'Welcome to the platform!');
// Output: 📧 Sending notification to User user1: "Welcome to the platform!"

import { Sim } from '@dooboostore/simple-boot/decorators/SimDecorator';

// Define symbol for interface
const ILogger = Symbol.for('ILogger');

// Register with symbol
@Sim({ symbol: ILogger })
class ConsoleLogger {
  log(message: string) {
    console.log(`[Console] ${message}`);
  }
}

@Sim({ symbol: ILogger })
class FileLogger {
  log(message: string) {
    console.log(`[File] ${message}`);
  }
}

// Usage
const app = new SimpleApplication().run();

// Get all implementations of ILogger
const loggers = app.sims(ILogger);
loggers.forEach(logger => logger.log('Hello!'));
// Output:
// [Console] Hello!
// [File] Hello!

// Get first implementation
const logger = app.sim(ILogger);
logger.log('First logger');

import { Sim } from '@dooboostore/simple-boot/decorators/SimDecorator';
import { Route, Router } from '@dooboostore/simple-boot/decorators/route/Router';

// User Controller
@Sim
@Router({ path: '/user' })
class UserController {
  constructor() {
    console.log('[UserController] Created');
  }

  @Route({ path: '/list' })
  listUsers() {
    console.log('📋 [Route] /user/list - Listing all users');
    return { users: ['Alice', 'Bob', 'Charlie'] };
  }

  @Route({ path: '/get' })
  getUser(id: string) {
    console.log(`👤 [Route] /user/get - Getting user: ${id}`);
    return { 
      id, 
      name: `User ${id}`, 
      email: `user${id}@example.com` 
    };
  }
}

// Product Controller
@Sim
@Router({ path: '/product' })
class ProductController {
  constructor() {
    console.log('[ProductController] Created');
  }

  @Route({ path: '/list' })
  listProducts() {
    console.log('📦 [Route] /product/list - Listing all products');
    return { products: ['Product A', 'Product B', 'Product C'] };
  }

  @Route({ path: '/detail' })
  getProduct(id: string) {
    console.log(`📦 [Route] /product/detail - Getting product: ${id}`);
    return { id, name: `Product ${id}`, price: 99.99 };
  }
}

// Usage
const app = new SimpleApplication().run();

// Controllers are automatically registered
const userController = app.sim(UserController);
userController.listUsers();
// Output: 📋 [Route] /user/list - Listing all users

userController.getUser('42');
// Output: 👤 [Route] /user/get - Getting user: 42

// Access routes via RouterManager
const routerManager = app.getRouterManager();
console.log('Registered routes:');
console.log('  - /user/list');
console.log('  - /user/get');
console.log('  - /product/list');
console.log('  - /product/detail');

import { Sim } from '@dooboostore/simple-boot/decorators/SimDecorator';
import { Cache } from '@dooboostore/simple-boot/decorators/cache/CacheDecorator';

@Sim
class DataService {
  private callCount = 0;

  @Cache({
    key: (userId: string) => `user-${userId}`
  })
  fetchUserData(userId: string): any {
    this.callCount++;
    console.log(`💾 Database call #${this.callCount} for user: ${userId}`);
    
    // Simulate expensive database operation
    return {
      id: userId,
      name: `User ${userId}`,
      email: `user${userId}@example.com`,
      timestamp: new Date().toISOString()
    };
  }

  @Cache({
    key: (n: number) => `calc-${n}`,
    ms: 5000  // Cache for 5 seconds
  })
  expensiveCalculation(n: number): number {
    this.callCount++;
    console.log(`🔢 Calculation #${this.callCount} for: ${n}`);
    
    // Simulate expensive computation
    let result = 0;
    for (let i = 0; i

import { SimpleApplication } from '@dooboostore/simple-boot/SimpleApplication';
import { Intent } from '@dooboostore/simple-boot/intent/Intent';

const app = new SimpleApplication().run();
const intentManager = app.getIntentManager();

// 1️⃣ URI-based Intent
console.log('Publishing intent to /user/created...');
const intent1 = new Intent('/user/created', { 
  userId: 'user-123', 
  name: 'Alice' 
});
await intentManager.publish(intent1);
console.log('✅ Intent published!');

// 2️⃣ Scheme-based Intent
console.log('Publishing intent with custom scheme...');
const intent2 = new Intent('myapp://order/placed', { 
  orderId: 'order-456', 
  amount: 99.99 
});
await intentManager.publish(intent2);
console.log('✅ Intent published!');

// 3️⃣ Symbol-based Intent
console.log('Publishing intent with Symbol...');
const intent3 = new Intent(
  { symbol: Symbol.for('payment'), uri: '/processed' },
  { orderId: 'order-456', success: true }
);
await intentManager.publish(intent3);
console.log('✅ Intent published!');

// 4️⃣ Simple String Intent
const result = await intentManager.publish('/api/hello', { 
  message: 'Hello World!' 
});
console.log(`✅ Published to /api/hello`);

import { Sim } from '@dooboostore/simple-boot/decorators/SimDecorator';
import { Intent } from '@dooboostore/simple-boot/intent/Intent';

// Define event types
class UserCreatedEvent {
  constructor(public userId: string, public name: string) {}
}

class OrderPlacedEvent {
  constructor(public orderId: string, public amount: number) {}
}

// Publisher Service
@Sim
class UserService {
  constructor(private intentManager: IntentManager) {}

  async createUser(name: string) {
    const userId = `user-${Date.now()}`;
    console.log(`👤 Creating user: ${name}`);
    
    // Publish event
    const intent = new Intent('/user/created', { userId, name });
    await this.intentManager.publish(intent);
    
    return { userId, name };
  }
}

// Subscriber Services
@Sim
class EmailService {
  constructor(private intentManager: IntentManager) {
    // Subscribe to events
    this.intentManager.subscribe('/user/created', (event) => {
      this.sendWelcomeEmail(event.data);
    });
  }

  private sendWelcomeEmail(data: any) {
    console.log(`📧 [EmailService] Sending welcome email to ${data.name}`);
  }
}

@Sim
class AnalyticsService {
  constructor(private intentManager: IntentManager) {
    this.intentManager.subscribe('/user/created', (event) => {
      this.trackUserCreation(event.data);
    });
  }

  private trackUserCreation(data: any) {
    console.log(`📊 [AnalyticsService] Tracking user creation: ${data.userId}`);
  }
}

// Usage
const app = new SimpleApplication().run();
const userService = app.sim(UserService);
const emailService = app.sim(EmailService); // Subscribers auto-initialized
const analyticsService = app.sim(AnalyticsService);

// Create user - both services will be notified
await userService.createUser('Alice');
// Output:
// 👤 Creating user: Alice
// 📧 [EmailService] Sending welcome email to Alice
// 📊 [AnalyticsService] Tracking user creation: user-1234567890

import { AlertType } from '@dooboostore/simple-boot/alert/AlertType';

// Available alert types:
AlertType.DANGER   // Critical errors
AlertType.SUCCESS  // Success messages
AlertType.INFO     // Informational messages
AlertType.WARNING  // Warning messages
AlertType.ERROR    // Error messages
AlertType.PROGRESS // Progress indicators

// Alert System Architecture:
// Components:
//   - AlertService: Manages alerts and subscriptions
//   - AlertFactory: Creates alert instances
//   - Alert: Individual alert instances
//   - AlertAction: Actions (SHOW, HIDE, UPDATE, REMOVE)

// Usage Pattern:
// 1. Create AlertFactory with @Sim decorator
// 2. AlertService auto-injected with AlertFactory
// 3. Create alerts: alertService.danger(), .success(), etc.
// 4. Subscribe to observable: alertService.observable.subscribe()
// 5. Perform actions on alerts: show(), hide(), update()