Entity modeling

interface CustomerProps {
  id: string;
  firstName: string;
  lastName: string;
  email: string;
  phone: string;
  birthDate: Date;
  street: string;
  number: string;
  complement: string | null;
  city: string;
  state: string;
  zipCode: string;
  country: string;
  newsletterOptIn: boolean;
  smsOptIn: boolean;
  preferredLanguage: string;
  taxId: string | null;
  taxRegime: string | null;
  invoiceEmail: string | null;
}

class Customer {
  constructor(public readonly props: CustomerProps) {}
}

interface CustomerProps {
  readonly id: CustomerId;
  readonly name: string;
  readonly email: string;
  readonly address: Address;
  readonly preferences: CustomerPreferences;
  readonly taxInfo: TaxInfo | null;
}

class Customer {
  constructor(private readonly props: CustomerProps) {}
}

interface Address {
  readonly street: string;
  readonly number: string;
  readonly complement: string | null;
  readonly city: string;
  readonly state: string;
  readonly zipCode: string;
  readonly country: string;
}

interface CustomerPreferences {
  readonly newsletterOptIn: boolean;
  readonly smsOptIn: boolean;
  readonly preferredLanguage: string;
}

interface TaxInfo {
  readonly taxId: string;
  readonly taxRegime: string;
  readonly invoiceEmail: string;
}

interface CustomerProps {
  readonly id: CustomerId;
  readonly name: string;
  readonly email: string;
  readonly taxId: string | null;
  readonly taxRegime: string | null;
  readonly invoiceEmail: string | null;
}

class Customer {
  constructor(private readonly props: CustomerProps) {}

  hasTaxInfo(): boolean {
    const isFiscallyRegistered =
      this.props.taxId !== null && this.props.taxRegime !== null;
    return isFiscallyRegistered;
  }
}

interface TaxInfoProps {
  readonly taxId: string;
  readonly taxRegime: string;
  readonly invoiceEmail: string;
}

class TaxInfo {
  private constructor(private readonly props: TaxInfoProps) {}

  static create(props: TaxInfoProps): TaxInfo {
    if (!props.taxId || !props.taxRegime) {
      throw new ValidationError({
        message: "TaxInfo requires both taxId and taxRegime.",
      });
    }

    const taxInfo = new TaxInfo(props);
    return taxInfo;
  }
}

interface CustomerProps {
  readonly id: CustomerId;
  readonly name: string;
  readonly email: string;
  readonly taxInfo: TaxInfo | null;
}

class Customer {
  constructor(private readonly props: CustomerProps) {}

  hasTaxInfo(): boolean {
    const isFiscallyRegistered = this.props.taxInfo !== null;
    return isFiscallyRegistered;
  }
}

function transferOwnership(customerId: string, orderId: string): Promise<void> {
  const updated = orderRepository.update(orderId, { customerId });
  return updated;
}

const newOwnerId = customer.id;
const targetOrderId = order.id;

// inverte argumentos: nada acusa, tipo de ambos é string
transferOwnership(targetOrderId, newOwnerId);

type CustomerId = string & { readonly __brand: "CustomerId" };
type OrderId = string & { readonly __brand: "OrderId" };

function customerId(value: string): CustomerId {
  if (!value) {
    throw new ValidationError({ message: "CustomerId requires a value." });
  }

  const branded = value as CustomerId;
  return branded;
}

function orderId(value: string): OrderId {
  if (!value) {
    throw new ValidationError({ message: "OrderId requires a value." });
  }

  const branded = value as OrderId;
  return branded;
}

function transferOwnership(
  customerId: CustomerId,
  orderId: OrderId,
): Promise<void> {
  const updated = orderRepository.update(orderId, { customerId });
  return updated;
}

const newOwnerId = customerId(customer.idValue);
const targetOrderId = orderId(order.idValue);

// trocar a ordem: erro de compilação
transferOwnership(targetOrderId, newOwnerId);
//                ^^^^^^^^^^^^^^ Argument of type 'OrderId' is not assignable
//                               to parameter of type 'CustomerId'.

type Brand<TValue, TTag extends string> = TValue & {
  readonly __brand: TTag;
};

type CustomerId = Brand<string, "CustomerId">;
type OrderId = Brand<string, "OrderId">;
type ProductId = Brand<string, "ProductId">;
type InvoiceId = Brand<string, "InvoiceId">;

function brandedId<TId extends Brand<string, string>>(
  value: string,
  label: string,
): TId {
  if (!value) {
    throw new ValidationError({ message: `${label} requires a value.` });
  }

  const branded = value as TId;
  return branded;
}

const newOwnerId = brandedId<CustomerId>(rawCustomerId, "CustomerId");
const targetOrderId = brandedId<OrderId>(rawOrderId, "OrderId");

abstract class BaseEntity {
  constructor(
    public readonly id: string,
    public readonly createdAt: Date,
    public readonly updatedAt: Date,
    public readonly deletedAt: Date | null,
    public readonly version: number,
    public readonly tenantId: string,
    public readonly createdBy: string,
    public readonly updatedBy: string,
  ) {}
}

class OrderItem extends BaseEntity {
  constructor(
    id: string,
    public readonly productId: string,
    public readonly quantity: number,
  ) {
    super(id, new Date(), new Date(), null, 1, "", "", "");
  }
}

abstract class Entity<TId extends Brand<string, string>> {
  protected constructor(public readonly id: TId) {}

  equals(other: Entity<TId>): boolean {
    const isSameClass = other instanceof this.constructor;
    const isSameId = isSameClass && other.id === this.id;
    return isSameId;
  }
}

interface AuditFields {
  readonly createdAt: Date;
  readonly updatedAt: Date;
  readonly createdBy: string | null;
  readonly updatedBy: string | null;
}

interface CustomerProps {
  readonly id: CustomerId;
  readonly name: string;
  readonly email: string;
  readonly audit: AuditFields;
}

class Customer extends Entity<CustomerId> {
  private constructor(private readonly props: CustomerProps) {
    super(props.id);
  }

  static rehydrate(props: CustomerProps): Customer {
    const customer = new Customer(props);
    return customer;
  }
}

interface OrderItemProps {
  readonly id: OrderItemId;
  readonly productId: ProductId;
  readonly quantity: number;
}

class OrderItem extends Entity<OrderItemId> {
  constructor(private readonly props: OrderItemProps) {
    super(props.id);
  }
}

interface CustomerProps {
  readonly id: CustomerId;
  readonly name: string;
  phone1: string | null;
  phone2: string | null;
  phone3: string | null;
}

class Customer {
  constructor(private readonly props: CustomerProps) {}

  addPhone(value: string): void {
    if (!this.props.phone1) {
      this.props.phone1 = value;
      return;
    }
    if (!this.props.phone2) {
      this.props.phone2 = value;
      return;
    }
    if (!this.props.phone3) {
      this.props.phone3 = value;
      return;
    }

    throw new ValidationError({ message: "Customer accepts at most 3 phones." });
  }
}

type PhoneType = "mobile" | "home" | "work";

interface Phone {
  readonly number: string;
  readonly type: PhoneType;
}

interface CustomerProps {
  readonly id: CustomerId;
  readonly name: string;
}

class Customer {
  private readonly phones: Phone[] = [];

  constructor(private readonly props: CustomerProps) {}

  get phoneList(): ReadonlyArray<Phone> {
    const snapshot = this.phones as ReadonlyArray<Phone>;
    return snapshot;
  }

  addPhone(phone: Phone): void {
    if (this.phones.length >= 3) {
      throw new ValidationError({
        message: "Customer can have at most 3 phones.",
      });
    }

    this.phones.push(phone);
  }

  removePhone(number: string): void {
    const remaining = this.phones.filter((phone) => phone.number !== number);
    this.phones.length = 0;
    this.phones.push(...remaining);
  }
}

class Order {
  public readonly items: OrderItem[] = [];

  constructor(public readonly id: OrderId) {}
}

class OrderItem {
  constructor(
    public readonly id: OrderItemId,
    public readonly order: Order, // referência completa
    public readonly productId: ProductId,
    public readonly quantity: number,
  ) {}
}

const order = new Order(orderIdentifier);
const item = new OrderItem(itemIdentifier, order, productIdentifier, 2);
order.items.push(item);

// quem valida que items.length não passa do limite? quem garante que removeItem
// limpa item.order? a regra fica diluída entre as duas classes.

interface OrderItemProps {
  readonly id: OrderItemId;
  readonly productId: ProductId;
  readonly quantity: number;
  readonly unitPrice: Money;
}

class OrderItem {
  private constructor(private readonly props: OrderItemProps) {}

  static create(props: OrderItemProps): OrderItem {
    if (props.quantity <= 0) {
      throw new ValidationError({ message: "Quantity must be positive." });
    }

    const item = new OrderItem(props);
    return item;
  }

  get id(): OrderItemId {
    return this.props.id;
  }

  subtotal(): Money {
    const total = this.props.unitPrice.multiply(this.props.quantity);
    return total;
  }
}

interface OrderProps {
  readonly id: OrderId;
  readonly customerId: CustomerId;
}

class Order extends Entity<OrderId> {
  private readonly items: OrderItem[] = [];

  private constructor(private readonly props: OrderProps) {
    super(props.id);
  }

  static place(props: OrderProps): Order {
    const order = new Order(props);
    return order;
  }

  get lineItems(): ReadonlyArray<OrderItem> {
    const snapshot = this.items as ReadonlyArray<OrderItem>;
    return snapshot;
  }

  addItem(input: Omit<OrderItemProps, "id">): void {
    if (this.items.length >= 50) {
      throw new ValidationError({ message: "Order can have at most 50 items." });
    }

    const item = OrderItem.create({
      id: orderItemId(crypto.randomUUID()),
      productId: input.productId,
      quantity: input.quantity,
      unitPrice: input.unitPrice,
    });
    this.items.push(item);
  }

  removeItem(itemIdentifier: OrderItemId): void {
    const remaining = this.items.filter((item) => item.id !== itemIdentifier);
    this.items.length = 0;
    this.items.push(...remaining);
  }

  total(): Money {
    const total = this.items.reduce(
      (sum, item) => sum.add(item.subtotal()),
      Money.zero(),
    );
    return total;
  }
}

interface StudentProps {
  readonly id: StudentId;
  readonly name: string;
  readonly courseIds: CourseId[];
  readonly enrollmentDates: Date[]; // paralelo a courseIds, por índice
}

class Student {
  constructor(private readonly props: StudentProps) {}

  enrollmentDateOf(courseIdentifier: CourseId): Date | null {
    const position = this.props.courseIds.findIndex(
      (id) => id === courseIdentifier,
    );
    if (position === -1) {
      return null;
    }

    const enrolledAt = this.props.enrollmentDates[position] ?? null;
    return enrolledAt;
  }
}

type EnrollmentStatus = "active" | "completed" | "withdrawn";

interface EnrollmentProps {
  readonly id: EnrollmentId;
  readonly studentId: StudentId;
  readonly courseId: CourseId;
  readonly enrolledAt: Date;
  readonly status: EnrollmentStatus;
  readonly finalGrade: number | null;
}

class Enrollment extends Entity<EnrollmentId> {
  private constructor(private props: EnrollmentProps) {
    super(props.id);
  }

  static open(input: Omit<EnrollmentProps, "status" | "finalGrade">): Enrollment {
    const enrollment = new Enrollment({
      ...input,
      status: "active",
      finalGrade: null,
    });
    return enrollment;
  }

  complete(grade: number): void {
    if (this.props.status !== "active") {
      throw new ValidationError({
        message: "Only active enrollments can be completed.",
      });
    }
    if (grade < 0 || grade > 10) {
      throw new ValidationError({ message: "Grade must be between 0 and 10." });
    }

    this.props = { ...this.props, status: "completed", finalGrade: grade };
  }
}

class Student extends Entity<StudentId> {
  constructor(props: { readonly id: StudentId; readonly name: string }) {
    super(props.id);
  }
}

class Course extends Entity<CourseId> {
  constructor(props: { readonly id: CourseId; readonly title: string }) {
    super(props.id);
  }
}

interface OrderProps {
  readonly id: OrderId;
  readonly customer: Customer; // Customer completo
  readonly items: ReadonlyArray<OrderItem>;
}

class Order extends Entity<OrderId> {
  constructor(private readonly props: OrderProps) {
    super(props.id);
  }
}

// para criar Order, preciso buscar Customer inteiro do banco
const customer = await customerRepository.findById(targetCustomerId);
if (!customer) {
  throw new NotFoundError({ message: "Customer not found." });
}

const order = new Order({ id: newOrderId, customer, items: [] });

// para serializar Order para o frontend, vou junto enviar Customer completo
// mudanças em Customer (email, telefone) podem invalidar o cache de Order

interface OrderProps {
  readonly id: OrderId;
  readonly customerId: CustomerId; // ID, não Customer
  readonly items: ReadonlyArray<OrderItem>;
}

class Order extends Entity<OrderId> {
  constructor(private readonly props: OrderProps) {
    super(props.id);
  }

  get customerId(): CustomerId {
    return this.props.customerId;
  }
}

const order = new Order({ id: newOrderId, customerId: targetCustomerId, items: [] });

// quem precisa do Customer resolve o ID no momento certo
const customer = await customerRepository.findById(order.customerId);

type OrderState =
  | { readonly status: "pending" }
  | { readonly status: "settled"; readonly settledAt: Date }
  | { readonly status: "shipped"; readonly settledAt: Date; readonly trackingCode: string }
  | { readonly status: "cancelled"; readonly cancelledAt: Date; readonly reason: string };

function summarize(state: OrderState): string {
  if (state.status === "settled") {
    const summary = `Settled at ${state.settledAt.toISOString()}`;
    return summary;
  }
  if (state.status === "shipped") {
    const summary = `Shipped, tracking ${state.trackingCode}`;
    return summary;
  }
  if (state.status === "cancelled") {
    const summary = `Cancelled: ${state.reason}`;
    return summary;
  }

  const summary = "Pending";
  return summary;
}

type TenantId = Brand<string, "TenantId">;

interface OrderProps {
  readonly id: OrderId;
  readonly tenantId: TenantId;
  readonly customerId: CustomerId;
  readonly items: ReadonlyArray<OrderItem>;
}

interface OrderItemProps {
  readonly id: OrderItemId;
  readonly tenantId: TenantId; // duplica o tenantId do Order
  readonly productId: ProductId;
  readonly quantity: number;
}

function calculateOrderTotal(order: Order, currentTenant: TenantId): Money {
  if (order.tenantId !== currentTenant) {
    throw new ForbiddenError({ message: "Tenant mismatch on order." });
  }
  for (const item of order.lineItems) {
    if (item.tenantId !== currentTenant) {
      throw new ForbiddenError({ message: "Tenant mismatch on item." });
    }
  }

  const total = order.total();
  return total;
}

type TenantId = Brand<string, "TenantId">;

interface OrderProps {
  readonly id: OrderId;
  readonly tenantId: TenantId; // único campo de tenant no agregado
  readonly customerId: CustomerId;
}

class Order extends Entity<OrderId> {
  constructor(private readonly props: OrderProps) {
    super(props.id);
  }

  get tenantId(): TenantId {
    return this.props.tenantId;
  }
}

interface OrderItemProps {
  readonly id: OrderItemId;
  readonly productId: ProductId;
  readonly quantity: number;
}

interface TenantContext {
  current(): TenantId;
}

class OrderRepository {
  constructor(
    private readonly connection: DatabaseConnection,
    private readonly tenantContext: TenantContext,
  ) {}

  async findById(identifier: OrderId): Promise<Order | null> {
    const activeTenant = this.tenantContext.current();
    const row = await this.connection.queryOne<OrderRow>(
      "SELECT id, customer_id, tenant_id FROM orders WHERE id = $1 AND tenant_id = $2",
      [identifier, activeTenant],
    );
    if (!row) {
      return null;
    }

    const order = OrderMapper.toDomain(row);
    return order;
  }
}