ContextAI — Arquitectura Hexagonal

// src/features/drafts/application/ports/outbound/LLMGatewayPort.ts

export interface LLMGenerateInput {
  systemPrompt: string;
  userPrompt: string;
  maxTokens?: number;
}

export interface LLMGenerateOutput {
  contenido: string;
  tokens_used: number;
  model: string;
}

/** Puerto: describe CAPACIDAD, no tecnología */
export interface LLMGatewayPort {
  generate(input: LLMGenerateInput): Promise<LLMGenerateOutput>;
}

// ─────────────────────────────────────────────────────────────
// src/features/drafts/application/ports/outbound/DraftRepositoryPort.ts

import { Borrador } from '../../domain/Borrador';

export interface DraftRepositoryPort {
  save(borrador: Borrador): Promise<void>;
  findById(id: string): Promise<Borrador | null>;
}

// ─────────────────────────────────────────────────────────────
// src/features/drafts/application/ports/outbound/EventBusPort.ts

export interface DomainEvent {
  type: string;
  payload: Record<string, unknown>;
  occurredAt: Date;
}

export interface EventBusPort {
  publish(event: DomainEvent): Promise<void>;
}

// ─────────────────────────────────────────────────────────────
// src/features/drafts/application/ports/outbound/WorkspaceRepositoryPort.ts

import { Workspace } from '../../domain/Workspace';

export interface WorkspaceRepositoryPort {
  findById(workspaceId: string): Promise<Workspace | null>;
}

// src/features/drafts/application/use-cases/GenerarBorradorUseCase.ts
// Orquesta SOLO lógica de aplicación. Cero imports de Express/Supabase/Anthropic.

import { Borrador } from '../domain/Borrador';
import { CreditosInsuficientesError } from '../domain/BorradorErrors';
import { DraftRepositoryPort } from './ports/outbound/DraftRepositoryPort';
import { LLMGatewayPort } from './ports/outbound/LLMGatewayPort';
import { EventBusPort } from './ports/outbound/EventBusPort';
import { WorkspaceRepositoryPort } from './ports/outbound/WorkspaceRepositoryPort';

export interface GenerarBorradorInput {
  draftId: string;
  workspaceId: string;
  brief: string;
  userId: string;
}

export interface GenerarBorradorOutput {
  draftId: string;
  contenido: string;
  tokens_used: number;
  status: string;
}

export class GenerarBorradorUseCase {
  constructor(
    private readonly workspaceRepo: WorkspaceRepositoryPort,
    private readonly draftRepo: DraftRepositoryPort,
    private readonly llmGateway: LLMGatewayPort,
    private readonly eventBus: EventBusPort,
  ) {}

  async execute(input: GenerarBorradorInput): Promise<GenerarBorradorOutput> {
    // 1. Cargar workspace y validar créditos (regla de negocio)
    const workspace = await this.workspaceRepo.findById(input.workspaceId);
    if (!workspace) throw new Error(`Workspace ${input.workspaceId} not found`);

    if (!workspace.hasCredits()) {
      throw new CreditosInsuficientesError(workspace.id);
    }

    // 2. Crear entidad borrador en estado pending
    let borrador = Borrador.create({ id: input.draftId, workspaceId: input.workspaceId, brief: input.brief });
    await this.draftRepo.save(borrador);

    // 3. Llamar al LLM (sin saber si es Anthropic u OpenAI)
    const llmResult = await this.llmGateway.generate({
      systemPrompt: 'Eres un experto copywriter de marketing. Responde en español.',
      userPrompt: input.brief,
      maxTokens: 2048,
    });

    // 4. Actualizar entidad (inmutable → nueva instancia)
    borrador = borrador.markReady(llmResult.contenido, llmResult.tokens_used);
    await this.draftRepo.save(borrador);

    // 5. Emitir evento de dominio
    await this.eventBus.publish({
      type: 'draft.created',
      payload: { draftId: borrador.id, workspaceId: borrador.workspaceId, tokens_used: borrador.tokens_used },
      occurredAt: new Date(),
    });

    return {
      draftId: borrador.id,
      contenido: borrador.contenido!,
      tokens_used: borrador.tokens_used,
      status: borrador.status,
    };
  }
}

// src/features/drafts/adapters/outbound/AnthropicLLMGateway.ts
// Antes era OpenAILLMGateway.ts — cambio de provider en UN archivo

import Anthropic from '@anthropic-ai/sdk';
import { LLMGatewayPort, LLMGenerateInput, LLMGenerateOutput } from
  '../../application/ports/outbound/LLMGatewayPort';

export class AnthropicLLMGateway implements LLMGatewayPort {
  private readonly client: Anthropic;

  constructor(apiKey: string) {
    this.client = new Anthropic({ apiKey });
  }

  async generate(input: LLMGenerateInput): Promise<LLMGenerateOutput> {
    const response = await this.client.messages.create({
      model: 'claude-3-5-sonnet-20241022',
      max_tokens: input.maxTokens ?? 2048,
      system: input.systemPrompt,
      messages: [{ role: 'user', content: input.userPrompt }],
    });

    const textBlock = response.content.find(b => b.type === 'text');
    if (!textBlock || textBlock.type !== 'text') {
      throw new Error('LLM returned no text block');
    }

    return {
      contenido: textBlock.text,
      tokens_used: response.usage.input_tokens + response.usage.output_tokens,
      model: response.model,
    };
  }
}

// ─────────────────────────────────────────────────────────────
// tests/fakes/InMemoryLLMGateway.ts  ← úsalo en unit tests

import { LLMGatewayPort, LLMGenerateInput, LLMGenerateOutput } from '...';

export class InMemoryLLMGateway implements LLMGatewayPort {
  public calls: LLMGenerateInput[] = [];
  public response: Partial<LLMGenerateOutput> = {};

  async generate(input: LLMGenerateInput): Promise<LLMGenerateOutput> {
    this.calls.push(input);
    return {
      contenido: this.response.contenido ?? '[Borrador generado en test]',
      tokens_used: this.response.tokens_used ?? 42,
      model: 'fake-model',
    };
  }
}

// src/features/drafts/composition/draftsContainer.ts
// Único punto de wiring — aquí viven los new. Nada más sabe de infraestructura.

import { SupabaseClient } from '@supabase/supabase-js';
import { Queue } from 'bull';

import { GenerarBorradorUseCase } from '../application/use-cases/GenerarBorradorUseCase';
import { SupabaseDraftRepository } from '../adapters/outbound/SupabaseDraftRepository';
import { SupabaseWorkspaceRepository } from '../adapters/outbound/SupabaseWorkspaceRepository';
import { AnthropicLLMGateway } from '../adapters/outbound/AnthropicLLMGateway';
import { BullEventBus } from '../adapters/outbound/RedisEventBus';

interface DraftsDeps {
  supabase: SupabaseClient;
  queue: Queue;
  anthropicApiKey: string;
}

export const buildDraftsContainer = (deps: DraftsDeps) => {
  // Instanciar adaptadores concretos
  const workspaceRepo = new SupabaseWorkspaceRepository(deps.supabase);
  const draftRepo = new SupabaseDraftRepository(deps.supabase);
  const llmGateway = new AnthropicLLMGateway(deps.anthropicApiKey);  // ← swap aquí
  const eventBus = new BullEventBus(deps.queue);

  // Inyectar en el use case (dominio no sabe de adaptadores)
  const generarBorradorUseCase = new GenerarBorradorUseCase(
    workspaceRepo, draftRepo, llmGateway, eventBus
  );

  return { generarBorradorUseCase };
};

// src/app.ts — punto de entrada
export const container = buildDraftsContainer({
  supabase: createSupabaseClient(process.env.SUPABASE_URL!, process.env.SUPABASE_KEY!),
  queue: new Queue('events', process.env.REDIS_URL!),
  anthropicApiKey: process.env.ANTHROPIC_API_KEY!,
});