import { createToken, Container } from "@brushy/di";

interface AuthService {
  login(email: string): Promise<void>;
}

class AuthServiceImpl implements AuthService {
  async login(email: string) {
    console.log(email);
  }
}

const AUTH = createToken<AuthService>("AUTH");
const container = new Container();

container.register(AUTH, { useClass: AuthServiceImpl });

// Type inferred automatically - no manual generic
const auth = container.resolve(AUTH);
await auth.login("user@example.com");

container.register(AuthServiceImpl, { useClass: AuthServiceImpl });
const auth = container.resolve(AuthServiceImpl); // type: AuthServiceImpl

import { defineModule } from "@brushy/di";

const appModule = defineModule({
  auth: { useClass: AuthServiceImpl },
  logger: { useValue: console },
});

appModule.register(container);

const auth = resolve(appModule.tokens.auth); // AuthService

import {
  runInRequestScope,
  runInRequestScopeAsync,
  brushyRequestScope,
  isRequestScopeSupported,
  server,
} from "@brushy/di";

app.use(server.brushyRequestScope());
// resolve() / inject.resolve() use the active scope - no manual scope argument

runInRequestScope(() => {
  const svc = resolve(USER_SERVICE);
});

await runInRequestScopeAsync(async () => {
  await resolveAsync(DATABASE);
});

import { resolve } from "@brushy/di";

// Resolve a dependency
const userService = resolve<UserService>("USER_SERVICE");

// Use the dependency
const users = await userService.getUsers();

// Resolve a dependency with specific scope
const requestService = resolve<RequestService>("REQUEST_SERVICE", requestScope);

import { inject } from "@brushy/di";

// Create container
const container = new Container();

// Configure as global container
inject.setGlobalContainer(container, {
  autoCleanRequestScope: true,
});

// Get the global container
const container = inject.getGlobalContainer();

// Resolve dependency
const userService = inject.resolve<UserService>("USER_SERVICE");

// Resolve async dependency
const database = await inject.resolveAsync<Database>("DATABASE");

// Clear request scope
inject.clearRequestScope();

import { cache } from "@brushy/di";

// Clear all promise cache
cache.clear();

// Clear cache for a specific token
cache.clear("USER_SERVICE");

import { monitor } from "@brushy/di";

// Create a monitor for a container
const containerMonitor = monitor.create(container, {
  eventTypes: ["resolve", "error"],
  logToConsole: true,
  maxEvents: 100,
});

// Get recorded events
const events = containerMonitor.getEvents();

// Get statistics
const stats = containerMonitor.getStats();
console.log(`Error rate: ${stats.errorRate * 100}%`);

// Stop monitoring
containerMonitor.stop();

// Clear history
containerMonitor.clearHistory();

import { BrushyDIProvider } from "@brushy/di";

// Create container
const container = new Container();

// Provide container to the application
function App() {
  return (
    <BrushyDIProvider container={container}>
      <YourApp />
    </BrushyDIProvider>
  );
}

// Create scope for the current request
const requestScope = {};

// Provide container with scope
function App() {
  return (
    <BrushyDIProvider container={container} scope={requestScope}>
      <YourApp />
    </BrushyDIProvider>
  );
}

import {
  Container,
  BrushyDIProvider,
  resolve,
  inject,
  cache,
  monitor,
} from "@brushy/di";

// Tokens
const LOGGER = Symbol("LOGGER");
const API_CLIENT = Symbol("API_CLIENT");
const USER_SERVICE = Symbol("USER_SERVICE");

// Classes
class Logger {
  log(message: string) {
    console.log(`[LOG] ${message}`);
  }
}

class ApiClient {
  constructor(private baseUrl: string) {}

  async get(path: string) {
    return fetch(`${this.baseUrl}${path}`).then((r) => r.json());
  }
}

class UserService {
  constructor(
    private apiClient: ApiClient,
    private logger: Logger,
  ) {}

  async getUsers() {
    this.logger.log("Fetching users");
    return this.apiClient.get("/users");
  }
}

// Create container
const container = new Container();

// Register dependencies
container.register(LOGGER, { useClass: Logger });
container.register(API_CLIENT, {
  useFactory: () => new ApiClient("https://api.example.com"),
  lifecycle: "singleton",
});
container.register(USER_SERVICE, {
  useClass: UserService,
  dependencies: [API_CLIENT, LOGGER],
});

// Configure global container
inject.setGlobalContainer(container);

// Create monitor
const containerMonitor = monitor.create(container, {
  eventTypes: ["all"],
  logToConsole: true,
});

// Function that uses global resolution
async function fetchUsers() {
  try {
    const userService = resolve<UserService>(USER_SERVICE);
    return await userService.getUsers();
  } catch (error) {
    console.error("Failed to fetch users:", error);
    return [];
  } finally {
    // Clear cache after use
    cache.clear(USER_SERVICE);
  }
}

// React Component
function UserList() {
  const [users, setUsers] = useState([]);
}