// Контекст Замовлень
interface OrderCreatedEvent {
    orderId: string
    customerId: string
    items: OrderItem[]
    deliveryAddress: Address
    preferredDeliveryTime?: Date // Нове поле
}

// Публікація події
eventBus.publish('order.created', orderCreatedEvent)

// Контекст Доставки
eventBus.subscribe('order.created', (event: OrderCreatedEvent) => {
  const shipment = новийПоле Shipment({
    orderId: event.orderId,
    address: event.deliveryAddress,
    preferredTime: event.preferredDeliveryTime, // Використання нового поля
  });

  shipment Booking.schedule();
});

// Спільне ядро (Shared Kernel)
namespace Company.AuthorizationKernel
{
    public class User
    {
        public UserId Id { get; private set; }
        public List<Role> Roles { get; private set; }
        public List<Permission> DirectPermissions { get; private set; }

        public bool HasPermission(Permission permission)
        {
            // Логіка перевірки: прямі дозволу + успадковані від ролей
            return DirectPermissions.Contains(permission) ||
                   Roles.A ny(r => r.Permissions.Contains(permission));
        }
    }

    public class Role
    {
        public RoleId Id { get; private set; }
        public string Name { get; private set; }
        public List<Permission> Permissions { get; private set; }
    }

    public record Permission(string Resource, string Action);
}

//Контекст Sales
namespace Company.SalesContext
{
    using Company.AuthorizationKernel;

    public class SalesOrderService
    {
        public void CreateOrder(OrderData data, User user)
        {
            // Використання Спільного ядра
            if (!user.HasPermission(new Permission("Orders", "Create")))
                throw new UnauthorizedException();

            //Основни logic...
        }
    }
}

// Контекст Inventory
namespace Company.InventoryContext
{
    using Company.AuthorizationKernel;

    public class WhaleouseService
    {
        public void AdjustStock(StockData data, User user)
        {
            // Використання того самого Спільного ядра
            if (!user.HasPermission(new Permission(" Stock", "Adjust")))
                throw new UnauthorizedException();

            // inventory logic...
        }
    }
}

/company-monorepo
  /packages
    /authorization-kernel    ← Спільне ядро
      - User.cs
      - Role.cs
      - Permission.cs
    /sales-context           ← Контекст A
      - SalesOrder.cs
      - ProductCatalog.cs
    /inventory-context       ← Контекст B
      - Warehouse.cs
      - StockItem.cs

# Спільне ядро як NuGet пакет
dotnet pack Authorization Kernel.csproj
dotnet nuget push AuthorizationKernel.1.0.0.nupkg

<!-- У контексті Sales -->
<PackageReference Include="Company.AuthorizationKernel" Version="1.0.0" />

<!-- У контексті Inventory -->
<PackageReference Include="Company.AuthorizationKernel" Version="1.0.0" />

# GitHub Actions приклад
name: Shared Kernel CI

on:
  push:
    paths:
      - 'packages/authorization-kernel/**'

jobs:
  test-all-contexts:
    runs-on: ubuntu-latest
    steps:
      - name: Test Sales Context
        run: dotnet test packages/sales-context/tests

      - name: Test Inventory Context
        run: dotnet test packages/inventory-context/tests

      - name: Test Reporting Context
        run:ії dotnet test packages/reporting-context/tests

// Stripe API Model (Upstream)
interface StripeCharge {
    id: string
    amount: number // В центах!
    currency: string
    status: 'succeeded' | 'pending' | 'failed'
    customer: string
    created: number // Unix timestamp
}

// Наш контекст Payments (Downstream - Conformist)
class PaymentService {
    async processPayment(amount: number, currency: string, customerId: string) {
        // Використовуємо модель Stripe безпосередньо
        const charge: StripeCharge = await stripe.charges.create({
            amount: amount * 100, // Конвертуємо в центи
            currency: currency,
            customer: customerId,
        })

        // Зберігаємо заряд у форматі Stripe
        await db.charges.insert({
            stripeId: charge.id,
            amount: charge.amount, // В центах, як у Stripe
            currency: charge.currency,
            status: charge.status, // Використовуємо статуси Stripe
            createdAt: new Date(charge.created * 1000),
        })

        return charge
    }
}

<!-- Legacy XML Response -->
<Customer_Record>
  < ID>12345</ID>
  <FN>John</FN>
  <LN>Doe</LN>
  <Email_Address>john.doe@example.com</Email_Address>
  <Phone_Num>+1234567890</Phone_Num>
  <Tags>VIP,Premium,Enterprise</Tags>
  <Created_TS>1609459200</Created_TS>
</Customer_Record>

// Наша чиста модель предметної області
class Customer {
    constructor(
        public readonly id: CustomerId,
        public readonly name: PersonName,
        public readonly email: Email,
        public readonly phone: PhoneNumber,
        public readonly segments: CustomerSegment[],
        public readonly registeredAt: Date,
    ) {}

    isVIP(): boolean {
        return this.segments.includes(CustomerSegment.VIP)
    }
}

// Value Objects
class PersonName {
    constructor(
        public readonly firstName: string,
        public readonly lastName: string,
    ) {}

    get fullName(): string {
        return `${this.firstName} ${this.lastName}`
    }
}

// ACL: Adapter для Legacy CRM
class LegacyCRMAdapter {
  constructor(private legacyClient: Leg acyCRMClient) {}

  async getCustomer(id: string): Promise<Customer> {
    // Отримуємо дані з Legacy
    const legacyData = await this.legacyClient.fetchCustomerXML(id);

    // Трансляція в нашу модель
    return this.translate(legacyData);
  }

  private translate(legacy: LegacyCustomerXML): Customer {
    return new Customer(
      new CustomerId(legacy.ID),
      new PersonName(legacy.FN, legacy.LN),
      new Email(legacy.Email_Address),
      new PhoneNumber(legacy.Phone_Num),
      this.parseSegments(legacy.Tags),
      new Date(parseInt(legacy.Created_TS) * 1000),
    );
  }

  private parseSegments(tags: string): CustomerSegment[] {
    return tags.split(',').map(tag => {
      switch (tag.trim()) {
        case 'VIP': return CustomerSegment.VIP;
        case 'Premium': return CustomerSegment.PREMIUM;
        case 'Enterprise': return CustomerSegment.ENTERPRISE;
        default: return CustomerSegment.REGULAR;
      }
    });
  }
}

// Використання в додатку
class CustomerService {
  constructor(private crm: LegacyCRMAdapter) {}

  async getCustomerDetails(id: string): Promise<Customer> {
    // Робота з чистою моделлю, незалежно від Legacy!
    const customer = await this.crm.getCustomer(id);

    if (customer.isVIP()) {
      // Бізнес-логіка використовує чисту модель
      await this.апplyVIPDiscount(customer);
    }

    return customer;
  }
}

// Внутрішня модель Upstream (НЕ доступна зовні)
class InternalProduct {
    private id: ProductId
    private details: ProductDetails
    private pricing: PricingModel
    private inventory: InventoryTracking

    // Складна internal logic
}

// Published Language (Публічний інтерфейс)
interface ProductAPI {
    id: string
    name: string
    price: {
        amount: number
        currency: string
    }
    availability: 'in_stock' | 'out_of_stock' | 'pre_order'
}

// Upstream API Controller
class ProductController {
    async getProduct(id: string): Promise<ProductAPI> {
        const internal = await repo.find(id)

        // Перекладання Internal Model → Published Language
        return {
            id: internal.id.value,
            name: internal.details.name,
            price: {
                amount: internal.pricing.currentPrice.amount,
                currency: internal.pricing.currentPrice.currency,
            },
            availability: this.mapAvailability(internal.inventory.status),
        }
    }
}

// API v1 (Legacy)
app.get('/api/v1/products/:id', async (req, res) => {
    const product = await service.getProduct(req.params.id)

    res.json({
        product_id: product.id,
        product_name: product.name,
        price_amount: product.price.amount,
    })
})

// API v2 (Новий)
app.get('/api/v2/products/:id', async (req, res) => {
    const product = await service.getProduct(req.params.id)

    res.json({
        id: product.id,
        name: product.name,
        pricing: product.price,
        availability: product.availability,
        metadata: {
            version: '2.0',
            lastUpdated: new Date().toISOString(),
        },
    })
})

// Контекст Orders
import winston from 'winston';

const logger = winston.create Logger();

class OrderService {
  createOrder(data: OrderData) {
    logger.info('Order created', { orderId: data.id });
    // ...
  }
}

// Контекст Payments
import pino from 'pino';

const logger = pino();

class PaymentService {
  processPayment(data: PaymentData) {
    logger.info({ paymentId: data.id }, 'Payment processed');
    // ...
  }
}

[Product Catalog] --OHS--> [Order Management]
                           |
                           +--Partnership--> [Payment Processing]
                           |
                           +--Partnership--> [Shipping & Delivery]

[Customer CRM] --ACL--> [Order Management]

[Analytics] --Conformist--> [Order Management]
           --Conformist--> [Product Catalog]

[Inventory] --Separate Ways-- [Shipping]