Domain model vs. DTO.

export function sharedLabel(ticket: TicketDTO): string {
	return `${ticket.requester_name} · ${ticket.status}`;
}

export function sharedNeedsReply(ticket: TicketDTO): boolean {
	return ticket.status !== 'closed' && ticket.unread_count > 0;
}

func SharedLabel(ticket TicketDTO) string {
	return fmt.Sprintf("%s · %s", ticket.Requester, ticket.Status)
}

func SharedNeedsReply(ticket TicketDTO) bool {
	return ticket.Status != string(StatusClosed) && ticket.UnreadCount > 0
}

export type TicketStatus = 'new' | 'open' | 'closed';
export type TicketId = string & { readonly __ticketId: unique symbol };

export type TicketDTO = {
	id: string;
	status: string;
	requester_name: string;
	updated_at: string;
	unread_count: number;
};

export type Ticket = Readonly<{
	id: TicketId;
	status: TicketStatus;
	requesterName: string;
	updatedAt: Date;
	unreadCount: number;
}>;

export type TicketSummary = Readonly<{
	id: string;
	label: string;
	needsReply: boolean;
}>;

export const incomingTicket: TicketDTO = {
	id: 'T-42',
	status: 'open',
	requester_name: 'Mina Alvarez',
	updated_at: '2026-09-15T08:30:00.000Z',
	unread_count: 2
};

export function sharedLabel(ticket: TicketDTO): string {
	return `${ticket.requester_name} · ${ticket.status}`;
}

export function sharedNeedsReply(ticket: TicketDTO): boolean {
	return ticket.status !== 'closed' && ticket.unread_count > 0;
}

const rfc3339 = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/;

function ticketId(value: string): TicketId {
	if (!/^T-[0-9]+$/.test(value)) throw new Error(`Invalid ticket id: ${value}`);
	return value as TicketId;
}

function status(value: string): TicketStatus {
	if (value === 'new' || value === 'open' || value === 'closed') return value;
	throw new Error(`Unknown ticket status: ${value}`);
}

export function toTicket(dto: TicketDTO): Ticket {
	// Accept RFC 3339 only, as Go's time.Parse does; new Date() alone accepts many other strings.
	const updatedAt = new Date(dto.updated_at);
	if (!rfc3339.test(dto.updated_at) || Number.isNaN(updatedAt.valueOf())) {
		throw new Error('Invalid ticket timestamp');
	}
	if (!Number.isInteger(dto.unread_count) || dto.unread_count < 0) {
		throw new Error('Unread count must be a non-negative integer');
	}
	return {
		id: ticketId(dto.id),
		status: status(dto.status),
		requesterName: dto.requester_name.trim(),
		updatedAt,
		unreadCount: dto.unread_count
	};
}

export function needsReply(ticket: Ticket): boolean {
	return ticket.status !== 'closed' && ticket.unreadCount > 0;
}

export function summary(ticket: Ticket): TicketSummary {
	return {
		id: ticket.id,
		label: `${ticket.requesterName} · ${ticket.status}`,
		needsReply: needsReply(ticket)
	};
}

export function example() {
	const domainTicket = toTicket(incomingTicket);
	return {
		shared: {
			label: sharedLabel(incomingTicket),
			needsReply: sharedNeedsReply(incomingTicket)
		},
		mapped: summary(domainTicket),
		isoDate: domainTicket.updatedAt.toISOString(),
		statusIsClosed: domainTicket.status === 'closed'
	};
}

console.log(JSON.stringify(example(), null, 2));

package main

import (
	"encoding/json"
	"errors"
	"fmt"
	"regexp"
	"strings"
	"time"
)

type TicketDTO struct {
	ID          string `json:"id"`
	Status      string `json:"status"`
	Requester   string `json:"requester_name"`
	UpdatedAt   string `json:"updated_at"`
	UnreadCount int    `json:"unread_count"`
}

type TicketStatus string

const (
	StatusNew    TicketStatus = "new"
	StatusOpen   TicketStatus = "open"
	StatusClosed TicketStatus = "closed"
)

type Ticket struct {
	ID            string
	Status        TicketStatus
	RequesterName string
	UpdatedAt     time.Time
	UnreadCount   int
}

var ticketIDPattern = regexp.MustCompile(`^T-[0-9]+$`)

func SharedLabel(ticket TicketDTO) string {
	return fmt.Sprintf("%s · %s", ticket.Requester, ticket.Status)
}

func SharedNeedsReply(ticket TicketDTO) bool {
	return ticket.Status != string(StatusClosed) && ticket.UnreadCount > 0
}


func ToTicket(dto TicketDTO) (Ticket, error) {
	if !ticketIDPattern.MatchString(dto.ID) {
		return Ticket{}, fmt.Errorf("invalid ticket id: %s", dto.ID)
	}
	status := TicketStatus(dto.Status)
	if status != StatusNew && status != StatusOpen && status != StatusClosed {
		return Ticket{}, fmt.Errorf("unknown ticket status: %s", dto.Status)
	}
	if dto.UnreadCount < 0 {
		return Ticket{}, errors.New("unread count must be non-negative")
	}
	updatedAt, err := time.Parse(time.RFC3339, dto.UpdatedAt)
	if err != nil {
		return Ticket{}, fmt.Errorf("invalid ticket timestamp: %w", err)
	}
	return Ticket{
		ID: dto.ID, Status: status, RequesterName: strings.TrimSpace(dto.Requester),
		UpdatedAt: updatedAt, UnreadCount: dto.UnreadCount,
	}, nil
}

func NeedsReply(ticket Ticket) bool {
	return ticket.Status != StatusClosed && ticket.UnreadCount > 0
}

type TicketSummary struct {
	ID         string `json:"id"`
	Label      string `json:"label"`
	NeedsReply bool   `json:"needsReply"`
}

func Summary(ticket Ticket) TicketSummary {
	return TicketSummary{
		ID:         ticket.ID,
		Label:      fmt.Sprintf("%s · %s", ticket.RequesterName, ticket.Status),
		NeedsReply: NeedsReply(ticket),
	}
}


func Example() (map[string]any, error) {
	dto := TicketDTO{
		ID: "T-42", Status: "open", Requester: "Mina Alvarez",
		UpdatedAt: "2026-09-15T08:30:00Z", UnreadCount: 2,
	}
	ticket, err := ToTicket(dto)
	if err != nil {
		return nil, err
	}
	return map[string]any{
		"shared": map[string]any{"label": SharedLabel(dto), "needsReply": SharedNeedsReply(dto)},
		"mapped": Summary(ticket), "isoDate": ticket.UpdatedAt.Format(time.RFC3339),
		"statusIsClosed": ticket.Status == StatusClosed,
	}, nil
}


func main() {
	result, err := Example()
	if err != nil {
		panic(err)
	}
	encoded, err := json.MarshalIndent(result, "", "  ")
	if err != nil {
		panic(err)
	}
	fmt.Println(string(encoded))
}