Repository pattern & its critics.

export type Kind = 'laptop' | 'camera' | 'phone';
export type Item = { id: string; name: string; kind: Kind; needsRepair: boolean };
// returnedOn is '' while the loan is open.
export type Loan = {
	id: string;
	itemId: string;
	borrower: string;
	outOn: string;
	dueOn: string;
	returnedOn: string;
};
export type OverdueRow = { loanId: string; itemName: string; borrower: string; dueOn: string };
export type LoanWithItem = { loan: Loan; item: Item };

export const messages = {
	itemNotFound: 'item not found',
	itemOnLoan: 'item already on loan',
	itemNeedsRepair: 'item needs repair',
	loanNotFound: 'loan not found',
	loanReturned: 'loan already returned',
	invalidDay: 'invalid day',
	invalidLoanLength: 'loan length must be at least one day',
	invalidPage: 'invalid page',
	itemExists: 'item already exists',
	loanIdAssigned: 'loan id is assigned by the store',
	unsavedChange: 'equipment has an unsaved change',
	nothingToSave: 'equipment has no change to save',
	writeFailed: 'store write failed'
} as const;
export class LoanError extends Error {}

type Kind string

type Item struct {
	ID          string `json:"id"`
	Name        string `json:"name"`
	Kind        Kind   `json:"kind"`
	NeedsRepair bool   `json:"needsRepair"`
}

// Loan.ReturnedOn is "" while the loan is open.
type Loan struct {
	ID         string `json:"id"`
	ItemID     string `json:"itemId"`
	Borrower   string `json:"borrower"`
	OutOn      string `json:"outOn"`
	DueOn      string `json:"dueOn"`
	ReturnedOn string `json:"returnedOn"`
}

type OverdueRow struct {
	LoanID   string `json:"loanId"`
	ItemName string `json:"itemName"`
	Borrower string `json:"borrower"`
	DueOn    string `json:"dueOn"`
}

type LoanWithItem struct {
	Loan Loan
	Item Item
}

var (
	ErrItemNotFound      = errors.New("item not found")
	ErrItemOnLoan        = errors.New("item already on loan")
	ErrItemNeedsRepair   = errors.New("item needs repair")
	ErrLoanNotFound      = errors.New("loan not found")
	ErrLoanReturned      = errors.New("loan already returned")
	ErrInvalidDay        = errors.New("invalid day")
	ErrInvalidLoanLength = errors.New("loan length must be at least one day")
	ErrInvalidPage       = errors.New("invalid page")
	ErrItemExists        = errors.New("item already exists")
	ErrLoanIDAssigned    = errors.New("loan id is assigned by the store")
	ErrUnsavedChange     = errors.New("equipment has an unsaved change")
	ErrNothingToSave     = errors.New("equipment has no change to save")
	ErrWriteFailed       = errors.New("store write failed")
)

export type WriteOp = 'insertItem' | 'insertLoan' | 'updateItem' | 'updateLoan';
export type Query<Row> = {
	where?: (row: Row) => boolean; // Stands in for a WHERE clause the store evaluates.
	orderBy?: (a: Row, b: Row) => number;
	offset?: number;
	limit?: number;
};
export type Stats = { storeCalls: number; rowsLoaded: number };

function replaceRow<Row extends { id: string }>(rows: Row[], row: Row, missing: string): void {
	const index = rows.findIndex((found) => found.id === row.id);
	if (index < 0) throw new LoanError(missing);
	rows[index] = { ...row };
}

// Loan ids come from the store: L001, L002, … in insertion order. Seed loans must follow that numbering.
export class Store {
	#items: Item[];
	#loans: Loan[];
	#storeCalls = 0;
	#rowsLoaded = 0;
	#failOn: WriteOp | undefined;

	constructor(items: readonly Item[], loans: readonly Loan[]) {
		this.#items = items.map((item) => ({ ...item }));
		this.#loans = loans.map((loan) => ({ ...loan }));
	}
	items(query: Query<Item>): Item[] {
		return this.#select(
			this.#items.map((item) => ({ ...item })),
			query
		);
	}
	loans(query: Query<Loan>): Loan[] {
		return this.#select(
			this.#loans.map((loan) => ({ ...loan })),
			query
		);
	}
	// An inner join on loan.itemId, like one SQL query with a join.
	loansWithItems(query: Query<LoanWithItem>): LoanWithItem[] {
		const joined = this.#loans.flatMap((loan) =>
			this.#items
				.filter((item) => item.id === loan.itemId)
				.map((item) => ({ loan: { ...loan }, item: { ...item } }))
		);
		return this.#select(joined, query);
	}
	insertItem(item: Item): Item {
		this.#write('insertItem');
		if (this.#items.some((row) => row.id === item.id)) throw new LoanError(messages.itemExists);
		this.#items.push({ ...item });
		return { ...item };
	}
	insertLoan(loan: Loan): Loan {
		this.#write('insertLoan');
		if (loan.id !== '') throw new LoanError(messages.loanIdAssigned);
		const saved = { ...loan, id: loanId(this.#loans.length + 1) };
		this.#loans.push(saved);
		return { ...saved };
	}
	updateItem(item: Item): void {
		this.#write('updateItem');
		replaceRow(this.#items, item, messages.itemNotFound);
	}
	updateLoan(loan: Loan): void {
		this.#write('updateLoan');
		replaceRow(this.#loans, loan, messages.loanNotFound);
	}

	// One call per read or write method, including a write that fails. Rows loaded counts the
	// rows a read returns after filtering and paging; a joined loan-with-item is one row.
	stats(): Stats {
		return { storeCalls: this.#storeCalls, rowsLoaded: this.#rowsLoaded };
	}
	#select<Row>(rows: Row[], query: Query<Row>): Row[] {
		this.#storeCalls++;
		const found = query.where ? rows.filter(query.where) : rows;
		if (query.orderBy) found.sort(query.orderBy);
		const start = query.offset ?? 0;
		const page = found.slice(start, query.limit === undefined ? undefined : start + query.limit);
		this.#rowsLoaded += page.length;
		return page;
	}

	// Snapshot both tables; restore them if the work throws, then rethrow.
	transaction<T>(work: () => T): T {
		const items = [...this.#items];
		const loans = [...this.#loans];
		try {
			return work();
		} catch (error) {
			this.#items = items;
			this.#loans = loans;
			throw error;
		}
	}

	// Every later call to the chosen write fails before it changes anything.
	failWrite(op: WriteOp | undefined): void {
		this.#failOn = op;
	}
	#write(op: WriteOp): void {
		this.#storeCalls++;
		if (this.#failOn === op) throw new LoanError(messages.writeFailed);
	}
}

type WriteOp string

const (
	InsertItem WriteOp = "insertItem"
	InsertLoan WriteOp = "insertLoan"
	UpdateItem WriteOp = "updateItem"
	UpdateLoan WriteOp = "updateLoan"
)

// Query stands in for one statement: Where is its WHERE clause. A zero Limit means no limit.
type Query[Row any] struct {
	Where   func(Row) bool
	OrderBy func(a, b Row) int
	Offset  int
	Limit   int
}

type Stats struct {
	StoreCalls int `json:"storeCalls"`
	RowsLoaded int `json:"rowsLoaded"`
}

// Store assigns loan IDs L001, L002, … in insertion order. Seed loans must follow that numbering.
type Store struct {
	items      []Item
	loans      []Loan
	storeCalls int
	rowsLoaded int
	failOn     WriteOp
}

func NewStore(items []Item, loans []Loan) *Store {
	return &Store{items: slices.Clone(items), loans: slices.Clone(loans)}
}

func (s *Store) Items(q Query[Item]) []Item { return selectRows(s, s.items, q) }

func (s *Store) Loans(q Query[Loan]) []Loan { return selectRows(s, s.loans, q) }

// LoansWithItems is an inner join on Loan.ItemID, like one SQL query with a join.
func (s *Store) LoansWithItems(q Query[LoanWithItem]) []LoanWithItem {
	joined := []LoanWithItem{}
	for _, loan := range s.loans {
		for _, item := range s.items {
			if item.ID == loan.ItemID {
				joined = append(joined, LoanWithItem{Loan: loan, Item: item})
			}
		}
	}
	return selectRows(s, joined, q)
}

func (s *Store) InsertItem(item Item) (Item, error) {
	if err := s.write(InsertItem); err != nil {
		return Item{}, err
	}
	if slices.ContainsFunc(s.items, func(row Item) bool { return row.ID == item.ID }) {
		return Item{}, ErrItemExists
	}
	s.items = append(s.items, item)
	return item, nil
}

func (s *Store) InsertLoan(loan Loan) (Loan, error) {
	if err := s.write(InsertLoan); err != nil {
		return Loan{}, err
	}
	if loan.ID != "" {
		return Loan{}, ErrLoanIDAssigned
	}
	loan.ID = loanID(len(s.loans) + 1)
	s.loans = append(s.loans, loan)
	return loan, nil
}

func (s *Store) UpdateItem(item Item) error {
	if err := s.write(UpdateItem); err != nil {
		return err
	}
	return replaceRow(s.items, item, func(row Item) string { return row.ID }, ErrItemNotFound)
}

func (s *Store) UpdateLoan(loan Loan) error {
	if err := s.write(UpdateLoan); err != nil {
		return err
	}
	return replaceRow(s.loans, loan, func(row Loan) string { return row.ID }, ErrLoanNotFound)
}

func replaceRow[Row any](rows []Row, row Row, id func(Row) string, missing error) error {
	i := slices.IndexFunc(rows, func(found Row) bool { return id(found) == id(row) })
	if i < 0 {
		return missing
	}
	rows[i] = row
	return nil
}

// One call per read or write method, including a write that fails. Rows loaded counts the
// rows a read returns after filtering and paging; a joined loan-with-item is one row.
func (s *Store) Stats() Stats { return Stats{StoreCalls: s.storeCalls, RowsLoaded: s.rowsLoaded} }

// selectRows is a function because generic methods need Go 1.27 and go.mod declares 1.22. Rows are
// structs of strings and bools, so every row handed to Where, OrderBy, or the caller is a copy.
func selectRows[Row any](s *Store, rows []Row, q Query[Row]) []Row {
	s.storeCalls++
	found := []Row{}
	for _, row := range rows {
		if q.Where == nil || q.Where(row) {
			found = append(found, row)
		}
	}
	if q.OrderBy != nil {
		slices.SortStableFunc(found, q.OrderBy)
	}
	start := min(q.Offset, len(found))
	end := len(found)
	if q.Limit > 0 {
		end = min(start+q.Limit, end)
	}
	page := found[start:end]
	s.rowsLoaded += len(page)
	return page
}


// Transaction snapshots both tables and restores them if work returns an error or panics.
func (s *Store) Transaction(work func() error) error {
	items, loans := slices.Clone(s.items), slices.Clone(s.loans)
	committed := false
	defer func() {
		if !committed {
			s.items, s.loans = items, loans
		}
	}()
	if err := work(); err != nil {
		return err
	}
	committed = true
	return nil
}


// FailWrite makes every later call to op fail before it changes anything; "" clears it.
func (s *Store) FailWrite(op WriteOp) { s.failOn = op }

func (s *Store) write(op WriteOp) error {
	s.storeCalls++
	if s.failOn == op {
		return ErrWriteFailed
	}
	return nil
}

export function runExample(): string[] {
	const ids = (rows: readonly OverdueRow[]) => rows.map((row) => row.loanId).join(' ');
	const lines = ['overdue on 2026-09-14'];
	for (const alternative of alternatives) {
		const store = seedStore();
		const rows = openDesk(alternative, store).overdue('2026-09-14');
		const { storeCalls, rowsLoaded } = store.stats();
		lines.push(
			`${alternative}: ${ids(rows)} (store calls ${storeCalls}, rows loaded ${rowsLoaded})`
		);
	}
	lines.push('import checks out camera-2 again');
	for (const alternative of alternatives) {
		const store = seedStore();
		const row = { itemId: 'camera-2', borrower: 'Import', today: '2026-09-14', days: 7 };
		const [result] = importLoans([row], importWriters[alternative](store));
		const open = store.loans({ where: (loan) => loan.itemId === 'camera-2' && !loan.returnedOn });
		const outcome = result.loan ? `created ${result.loan.id}` : result.error;
		lines.push(`${alternative}: ${outcome}, open loans ${open.length}`);
	}
	lines.push(
		`fake on 2026-09-14: ${ids(new FakeEquipmentLoans(seedItems(), seedLoans()).overdue('2026-09-14'))}`
	);
	return lines;
}

func RunExample() ([]string, error) {
	ids := func(rows []OverdueRow) string {
		loanIDs := make([]string, 0, len(rows))
		for _, row := range rows {
			loanIDs = append(loanIDs, row.LoanID)
		}
		return strings.Join(loanIDs, " ")
	}
	lines := []string{"overdue on 2026-09-14"}
	for _, alternative := range Alternatives {
		s := SeedStore()
		rows, err := OpenDesk(alternative, s).Overdue("2026-09-14")
		if err != nil {
			return nil, err
		}
		stats := s.Stats()
		lines = append(lines, fmt.Sprintf("%s: %s (store calls %d, rows loaded %d)", alternative, ids(rows), stats.StoreCalls, stats.RowsLoaded))
	}
	lines = append(lines, "import checks out camera-2 again")
	for _, alternative := range Alternatives {
		s := SeedStore()
		row := ImportRow{ItemID: "camera-2", Borrower: "Import", Today: "2026-09-14", Days: 7}
		result := ImportLoans([]ImportRow{row}, ImportWriter(alternative, s))[0]
		open := s.Loans(Query[Loan]{Where: func(loan Loan) bool { return loan.ItemID == "camera-2" && loan.ReturnedOn == "" }})
		outcome := "created " + result.Loan.ID
		if result.Err != nil {
			outcome = result.Err.Error()
		}
		lines = append(lines, fmt.Sprintf("%s: %s, open loans %d", alternative, outcome, len(open)))
	}
	fake, err := NewFakeEquipmentLoans(SeedItems(), SeedLoans()).Overdue("2026-09-14")
	if err != nil {
		return nil, err
	}
	return append(lines, "fake on 2026-09-14: "+ids(fake)), nil
}

// Team equipment loans over an in-memory store. Days are ISO calendar-day strings compared as text.
export type Kind = 'laptop' | 'camera' | 'phone';
export type Item = { id: string; name: string; kind: Kind; needsRepair: boolean };
// returnedOn is '' while the loan is open.
export type Loan = {
	id: string;
	itemId: string;
	borrower: string;
	outOn: string;
	dueOn: string;
	returnedOn: string;
};
export type OverdueRow = { loanId: string; itemName: string; borrower: string; dueOn: string };
export type LoanWithItem = { loan: Loan; item: Item };

export const messages = {
	itemNotFound: 'item not found',
	itemOnLoan: 'item already on loan',
	itemNeedsRepair: 'item needs repair',
	loanNotFound: 'loan not found',
	loanReturned: 'loan already returned',
	invalidDay: 'invalid day',
	invalidLoanLength: 'loan length must be at least one day',
	invalidPage: 'invalid page',
	itemExists: 'item already exists',
	loanIdAssigned: 'loan id is assigned by the store',
	unsavedChange: 'equipment has an unsaved change',
	nothingToSave: 'equipment has no change to save',
	writeFailed: 'store write failed'
} as const;
export class LoanError extends Error {}

function compareText(a: string, b: string): number {
	if (a < b) return -1;
	if (a > b) return 1;
	return 0;
}
// Overdue order: due day, then loan id.
export function compareLoans(a: Loan, b: Loan): number {
	return compareText(a.dueOn, b.dueOn) || compareText(a.id, b.id);
}
function byDue(a: LoanWithItem, b: LoanWithItem): number {
	return compareLoans(a.loan, b.loan);
}
function isOverdue(loan: Loan, asOf: string): boolean {
	return loan.returnedOn === '' && loan.dueOn < asOf;
}
function toRow({ loan, item }: LoanWithItem): OverdueRow {
	return { loanId: loan.id, itemName: item.name, borrower: loan.borrower, dueOn: loan.dueOn };
}
export function validDay(day: string): string {
	const date = new Date(`${day}T00:00:00Z`);
	if (
		!/^\d{4}-\d{2}-\d{2}$/.test(day) ||
		Number.isNaN(date.getTime()) ||
		date.toISOString().slice(0, 10) !== day
	)
		throw new LoanError(messages.invalidDay);
	return day;
}
function dueDate(today: string, days: number): string {
	const date = new Date(`${validDay(today)}T00:00:00Z`);
	if (!Number.isInteger(days) || days < 1) throw new LoanError(messages.invalidLoanLength);
	date.setUTCDate(date.getUTCDate() + days);
	return date.toISOString().slice(0, 10);
}
function newLoan(itemId: string, borrower: string, today: string, days: number): Loan {
	const dueOn = dueDate(today, days);
	return { id: '', itemId, borrower, outOn: today, dueOn, returnedOn: '' };
}
function pageOffset(page: number, pageSize: number): number {
	if (!Number.isInteger(page) || page < 1 || !Number.isInteger(pageSize) || pageSize < 1)
		throw new LoanError(messages.invalidPage);
	return (page - 1) * pageSize;
}
function loanId(sequence: number): string {
	return `L${String(sequence).padStart(3, '0')}`;
}

export type WriteOp = 'insertItem' | 'insertLoan' | 'updateItem' | 'updateLoan';
export type Query<Row> = {
	where?: (row: Row) => boolean; // Stands in for a WHERE clause the store evaluates.
	orderBy?: (a: Row, b: Row) => number;
	offset?: number;
	limit?: number;
};
export type Stats = { storeCalls: number; rowsLoaded: number };

function replaceRow<Row extends { id: string }>(rows: Row[], row: Row, missing: string): void {
	const index = rows.findIndex((found) => found.id === row.id);
	if (index < 0) throw new LoanError(missing);
	rows[index] = { ...row };
}

// Loan ids come from the store: L001, L002, … in insertion order. Seed loans must follow that numbering.
export class Store {
	#items: Item[];
	#loans: Loan[];
	#storeCalls = 0;
	#rowsLoaded = 0;
	#failOn: WriteOp | undefined;

	constructor(items: readonly Item[], loans: readonly Loan[]) {
		this.#items = items.map((item) => ({ ...item }));
		this.#loans = loans.map((loan) => ({ ...loan }));
	}
	items(query: Query<Item>): Item[] {
		return this.#select(
			this.#items.map((item) => ({ ...item })),
			query
		);
	}
	loans(query: Query<Loan>): Loan[] {
		return this.#select(
			this.#loans.map((loan) => ({ ...loan })),
			query
		);
	}
	// An inner join on loan.itemId, like one SQL query with a join.
	loansWithItems(query: Query<LoanWithItem>): LoanWithItem[] {
		const joined = this.#loans.flatMap((loan) =>
			this.#items
				.filter((item) => item.id === loan.itemId)
				.map((item) => ({ loan: { ...loan }, item: { ...item } }))
		);
		return this.#select(joined, query);
	}
	insertItem(item: Item): Item {
		this.#write('insertItem');
		if (this.#items.some((row) => row.id === item.id)) throw new LoanError(messages.itemExists);
		this.#items.push({ ...item });
		return { ...item };
	}
	insertLoan(loan: Loan): Loan {
		this.#write('insertLoan');
		if (loan.id !== '') throw new LoanError(messages.loanIdAssigned);
		const saved = { ...loan, id: loanId(this.#loans.length + 1) };
		this.#loans.push(saved);
		return { ...saved };
	}
	updateItem(item: Item): void {
		this.#write('updateItem');
		replaceRow(this.#items, item, messages.itemNotFound);
	}
	updateLoan(loan: Loan): void {
		this.#write('updateLoan');
		replaceRow(this.#loans, loan, messages.loanNotFound);
	}

	// One call per read or write method, including a write that fails. Rows loaded counts the
	// rows a read returns after filtering and paging; a joined loan-with-item is one row.
	stats(): Stats {
		return { storeCalls: this.#storeCalls, rowsLoaded: this.#rowsLoaded };
	}
	#select<Row>(rows: Row[], query: Query<Row>): Row[] {
		this.#storeCalls++;
		const found = query.where ? rows.filter(query.where) : rows;
		if (query.orderBy) found.sort(query.orderBy);
		const start = query.offset ?? 0;
		const page = found.slice(start, query.limit === undefined ? undefined : start + query.limit);
		this.#rowsLoaded += page.length;
		return page;
	}

	// Snapshot both tables; restore them if the work throws, then rethrow.
	transaction<T>(work: () => T): T {
		const items = [...this.#items];
		const loans = [...this.#loans];
		try {
			return work();
		} catch (error) {
			this.#items = items;
			this.#loans = loans;
			throw error;
		}
	}

	// Every later call to the chosen write fails before it changes anything.
	failWrite(op: WriteOp | undefined): void {
		this.#failOn = op;
	}
	#write(op: WriteOp): void {
		this.#storeCalls++;
		if (this.#failOn === op) throw new LoanError(messages.writeFailed);
	}
}

export function listOverdueLoans(store: Store, asOf: string): OverdueRow[] {
	validDay(asOf);
	return store
		.loansWithItems({ where: ({ loan }) => isOverdue(loan, asOf), orderBy: byDue })
		.map(toRow);
}
export function listOverdueByKind(
	store: Store,
	asOf: string,
	kind: Kind,
	page: number,
	pageSize: number
): OverdueRow[] {
	validDay(asOf);
	const offset = pageOffset(page, pageSize);
	return store
		.loansWithItems({
			where: ({ loan, item }) => item.kind === kind && isOverdue(loan, asOf),
			orderBy: byDue,
			offset,
			limit: pageSize
		})
		.map(toRow);
}
export function checkOut(
	store: Store,
	itemId: string,
	borrower: string,
	today: string,
	days: number
): Loan {
	const item = store.items({ where: (row) => row.id === itemId }).at(0);
	if (!item) throw new LoanError(messages.itemNotFound);
	const open = store.loans({ where: (loan) => loan.itemId === itemId && loan.returnedOn === '' });
	if (open.length) throw new LoanError(messages.itemOnLoan);
	if (item.needsRepair) throw new LoanError(messages.itemNeedsRepair);
	return store.insertLoan(newLoan(itemId, borrower, today, days));
}
export function returnLoan(
	store: Store,
	loanId: string,
	today: string,
	needsRepair: boolean
): Loan {
	return store.transaction(() => {
		const loan = store.loans({ where: (row) => row.id === loanId }).at(0);
		if (!loan) throw new LoanError(messages.loanNotFound);
		if (loan.returnedOn !== '') throw new LoanError(messages.loanReturned);
		const closed = { ...loan, returnedOn: validDay(today) };
		store.updateLoan(closed);
		if (needsRepair) {
			const item = store.items({ where: (row) => row.id === loan.itemId }).at(0);
			if (!item) throw new LoanError(messages.itemNotFound);
			store.updateItem({ ...item, needsRepair: true });
		}
		return closed;
	});
}

export type Change =
	{ kind: 'open'; loan: Loan } | { kind: 'close'; loan: Loan; repair: Item | undefined };

// The aggregate: one item and its open loans. The checkout rule lives here.
export class Equipment {
	#item: Item;
	#openLoans: Loan[];
	#change: Change | undefined;

	constructor(item: Item, openLoans: readonly Loan[]) {
		this.#item = { ...item };
		this.#openLoans = openLoans.map((loan) => ({ ...loan }));
	}
	checkOut(borrower: string, today: string, days: number): void {
		if (this.#change) throw new LoanError(messages.unsavedChange);
		if (this.#openLoans.length) throw new LoanError(messages.itemOnLoan);
		if (this.#item.needsRepair) throw new LoanError(messages.itemNeedsRepair);
		this.#change = { kind: 'open', loan: newLoan(this.#item.id, borrower, today, days) };
	}
	// loanId must belong to this item; the repository's forLoan loads the item that owns it.
	return(loanId: string, today: string, needsRepair: boolean): void {
		if (this.#change) throw new LoanError(messages.unsavedChange);
		const loan = this.#openLoans.find((open) => open.id === loanId);
		if (!loan) throw new LoanError(messages.loanReturned);
		const closed = { ...loan, returnedOn: validDay(today) };
		const repair = needsRepair ? { ...this.#item, needsRepair: true } : undefined;
		this.#change = { kind: 'close', loan: closed, repair };
	}
	pendingChange(): Change {
		if (!this.#change) throw new LoanError(messages.nothingToSave);
		const { loan } = this.#change;
		if (this.#change.kind === 'open') return { kind: 'open', loan: { ...loan } };
		const { repair } = this.#change;
		return { kind: 'close', loan: { ...loan }, repair: repair && { ...repair } };
	}
	markSaved(loan: Loan): void {
		const change = this.pendingChange();
		if (change.kind === 'open') this.#openLoans.push({ ...loan });
		else {
			this.#openLoans = this.#openLoans.filter((open) => open.id !== loan.id);
			if (change.repair) this.#item = change.repair;
		}
		this.#change = undefined;
	}
}

// The use cases own these two small interfaces; the store-backed repository and the fake both fit.
export interface OverdueLoans {
	overdue(asOf: string): OverdueRow[];
}
export interface EquipmentWriter {
	forItem(itemId: string): Equipment | undefined;
	forLoan(loanId: string): Equipment | undefined;
	save(equipment: Equipment): Loan;
}

export class StoreEquipmentLoans implements OverdueLoans, EquipmentWriter {
	#store: Store;

	constructor(store: Store) {
		this.#store = store;
	}
	overdue(asOf: string): OverdueRow[] {
		validDay(asOf);
		return this.#store
			.loansWithItems({ where: ({ loan }) => isOverdue(loan, asOf), orderBy: byDue })
			.map(toRow);
	}
	// A new read shape is a new repository method.
	overdueByKind(asOf: string, kind: Kind, page: number, pageSize: number): OverdueRow[] {
		validDay(asOf);
		const offset = pageOffset(page, pageSize);
		return this.#store
			.loansWithItems({
				where: ({ loan, item }) => item.kind === kind && isOverdue(loan, asOf),
				orderBy: byDue,
				offset,
				limit: pageSize
			})
			.map(toRow);
	}
	forItem(itemId: string): Equipment | undefined {
		const item = this.#store.items({ where: (row) => row.id === itemId }).at(0);
		if (!item) return undefined;
		const open = this.#store.loans({
			where: (loan) => loan.itemId === itemId && loan.returnedOn === ''
		});
		return new Equipment(item, open);
	}
	forLoan(loanId: string): Equipment | undefined {
		const loan = this.#store.loans({ where: (row) => row.id === loanId }).at(0);
		return loan && this.forItem(loan.itemId);
	}
	// Both writes of a change happen in one transaction.
	save(equipment: Equipment): Loan {
		const change = equipment.pendingChange();
		const saved = this.#store.transaction(() => {
			if (change.kind === 'open') return this.#store.insertLoan(change.loan);
			this.#store.updateLoan(change.loan);
			if (change.repair) this.#store.updateItem(change.repair);
			return change.loan;
		});
		equipment.markSaved(saved);
		return saved;
	}
}

export function checkOutEquipment(
	loans: EquipmentWriter,
	itemId: string,
	borrower: string,
	today: string,
	days: number
): Loan {
	const equipment = loans.forItem(itemId);
	if (!equipment) throw new LoanError(messages.itemNotFound);
	equipment.checkOut(borrower, today, days);
	return loans.save(equipment);
}
export function returnEquipment(
	loans: EquipmentWriter,
	loanId: string,
	today: string,
	needsRepair: boolean
): Loan {
	const equipment = loans.forLoan(loanId);
	if (!equipment) throw new LoanError(messages.loanNotFound);
	equipment.return(loanId, today, needsRepair);
	return loans.save(equipment);
}
// The nightly reminder job.
export function reminders(loans: OverdueLoans, asOf: string): string[] {
	return loans.overdue(asOf).map((row) => `${row.borrower}: ${row.itemName} was due ${row.dueOn}`);
}

export interface Repository<T> {
	get(id: string): T | undefined;
	find(predicate: (entity: T) => boolean): T[];
	add(entity: T): T;
	update(entity: T): void;
}
type Table<T> = { select(query: Query<T>): T[]; insert(row: T): T; update(row: T): void };

function tableRepository<T extends { id: string }>(table: Table<T>): Repository<T> {
	return {
		// A key lookup the store can run.
		get: (id) => table.select({ where: (row) => row.id === id }).at(0),
		// The predicate is opaque code, so the store returns every row and the filter runs here.
		find: (predicate) => table.select({}).filter(predicate),
		add: (entity) => table.insert(entity),
		update: (entity) => table.update(entity)
	};
}
export type Repositories = { items: Repository<Item>; loans: Repository<Loan> };
export function storeRepositories(store: Store): Repositories {
	return {
		items: tableRepository<Item>({
			select: (query) => store.items(query),
			insert: (row) => store.insertItem(row),
			update: (row) => store.updateItem(row)
		}),
		loans: tableRepository<Loan>({
			select: (query) => store.loans(query),
			insert: (row) => store.insertLoan(row),
			update: (row) => store.updateLoan(row)
		})
	};
}

// Use cases written against Repository<T>. Filtering, joining, sorting, paging, and the rule are theirs.
function withItem(repos: Repositories, loan: Loan): LoanWithItem {
	const item = repos.items.get(loan.itemId); // One store call per loan.
	if (!item) throw new LoanError(messages.itemNotFound);
	return { loan, item };
}
export function genericOverdue(repos: Repositories, asOf: string): OverdueRow[] {
	validDay(asOf);
	return repos.loans
		.find((loan) => isOverdue(loan, asOf))
		.sort(compareLoans)
		.map((loan) => toRow(withItem(repos, loan)));
}
export function genericOverdueByKind(
	repos: Repositories,
	asOf: string,
	kind: Kind,
	page: number,
	pageSize: number
): OverdueRow[] {
	validDay(asOf);
	const offset = pageOffset(page, pageSize);
	return repos.loans
		.find((loan) => isOverdue(loan, asOf))
		.map((loan) => withItem(repos, loan))
		.filter(({ item }) => item.kind === kind)
		.sort(byDue)
		.slice(offset, offset + pageSize)
		.map(toRow);
}
export function genericCheckOut(
	repos: Repositories,
	itemId: string,
	borrower: string,
	today: string,
	days: number
): Loan {
	const item = repos.items.get(itemId);
	if (!item) throw new LoanError(messages.itemNotFound);
	if (repos.loans.find((loan) => loan.itemId === itemId && loan.returnedOn === '').length)
		throw new LoanError(messages.itemOnLoan);
	if (item.needsRepair) throw new LoanError(messages.itemNeedsRepair);
	return repos.loans.add(newLoan(itemId, borrower, today, days));
}
// Two separate updates: nothing here groups them.
export function genericReturn(
	repos: Repositories,
	loanId: string,
	today: string,
	needsRepair: boolean
): Loan {
	const loan = repos.loans.get(loanId);
	if (!loan) throw new LoanError(messages.loanNotFound);
	if (loan.returnedOn !== '') throw new LoanError(messages.loanReturned);
	const closed = { ...loan, returnedOn: validDay(today) };
	repos.loans.update(closed);
	if (needsRepair) {
		const item = repos.items.get(loan.itemId);
		if (!item) throw new LoanError(messages.itemNotFound);
		repos.items.update({ ...item, needsRepair: true });
	}
	return closed;
}

export const alternatives = ['direct', 'domain', 'generic', 'split'] as const;
export type Alternative = (typeof alternatives)[number];
// The three operations, plus the new read shape, bound to one alternative and one store.
export type LoanDesk = {
	overdue(asOf: string): OverdueRow[];
	overdueByKind(asOf: string, kind: Kind, page: number, pageSize: number): OverdueRow[];
	checkOut(itemId: string, borrower: string, today: string, days: number): Loan;
	returnLoan(loanId: string, today: string, needsRepair: boolean): Loan;
};
function directDesk(store: Store): LoanDesk {
	return {
		overdue: (asOf) => listOverdueLoans(store, asOf),
		overdueByKind: (asOf, kind, page, size) => listOverdueByKind(store, asOf, kind, page, size),
		checkOut: (itemId, borrower, today, days) => checkOut(store, itemId, borrower, today, days),
		returnLoan: (loanId, today, repair) => returnLoan(store, loanId, today, repair)
	};
}
function domainDesk(store: Store): LoanDesk {
	const loans = new StoreEquipmentLoans(store);
	return {
		overdue: (asOf) => loans.overdue(asOf),
		overdueByKind: (asOf, kind, page, size) => loans.overdueByKind(asOf, kind, page, size),
		checkOut: (itemId, borrower, today, days) =>
			checkOutEquipment(loans, itemId, borrower, today, days),
		returnLoan: (loanId, today, repair) => returnEquipment(loans, loanId, today, repair)
	};
}
function genericDesk(store: Store): LoanDesk {
	const repos = storeRepositories(store);
	return {
		overdue: (asOf) => genericOverdue(repos, asOf),
		overdueByKind: (asOf, kind, page, size) => genericOverdueByKind(repos, asOf, kind, page, size),
		checkOut: (itemId, borrower, today, days) =>
			genericCheckOut(repos, itemId, borrower, today, days),
		returnLoan: (loanId, today, repair) => genericReturn(repos, loanId, today, repair)
	};
}
export function openDesk(alternative: Alternative, store: Store): LoanDesk {
	switch (alternative) {
		case 'direct':
			return directDesk(store);
		case 'domain':
			return domainDesk(store);
		case 'generic':
			return genericDesk(store);
		case 'split':
			return splitDesk(store);
	}
	throw new Error(`unknown alternative: ${String(alternative)}`);
}

// Reads are query functions; writes go through the write repository and its rule.
export function splitDesk(store: Store): LoanDesk {
	const writes: EquipmentWriter = new StoreEquipmentLoans(store);
	return {
		overdue: (asOf) => listOverdueLoans(store, asOf),
		overdueByKind: (asOf, kind, page, size) => listOverdueByKind(store, asOf, kind, page, size),
		checkOut: (itemId, borrower, today, days) =>
			checkOutEquipment(writes, itemId, borrower, today, days),
		returnLoan: (loanId, today, repair) => returnEquipment(writes, loanId, today, repair)
	};
}

export type ImportRow = { itemId: string; borrower: string; today: string; days: number };
export type ImportResult = { loan: Loan | null; error: string | null };
// An import script checks equipment out too. What it can call depends on the boundary it was given.
export const importWriters: Record<Alternative, (store: Store) => (row: ImportRow) => Loan> = {
	// Direct functions leave the store in reach; nothing makes the script call checkOut.
	direct: (store) => (row) =>
		store.insertLoan(newLoan(row.itemId, row.borrower, row.today, row.days)),
	// Repository<Loan>.add stores whatever it is given.
	generic: (store) => (row) =>
		storeRepositories(store).loans.add(newLoan(row.itemId, row.borrower, row.today, row.days)),
	// The repository saves only Equipment changes, and Equipment.checkOut holds the rule.
	domain: (store) => (row) =>
		checkOutEquipment(
			new StoreEquipmentLoans(store),
			row.itemId,
			row.borrower,
			row.today,
			row.days
		),
	split: (store) => (row) =>
		checkOutEquipment(new StoreEquipmentLoans(store), row.itemId, row.borrower, row.today, row.days)
};
export function importLoans(
	rows: readonly ImportRow[],
	write: (row: ImportRow) => Loan
): ImportResult[] {
	return rows.map((row) => {
		try {
			return { loan: write(row), error: null };
		} catch (error) {
			if (error instanceof LoanError) return { loan: null, error: error.message };
			throw error;
		}
	});
}

// A hand-written fake for use-case tests. It keeps loans newest first and sorts by due day only,
// so tied due days come back newest first. The store-backed repository orders ties by loan id.
export class FakeEquipmentLoans implements OverdueLoans, EquipmentWriter {
	#items: Item[];
	#loans: Loan[];

	constructor(items: readonly Item[], loans: readonly Loan[]) {
		this.#items = items.map((item) => ({ ...item }));
		this.#loans = loans.map((loan) => ({ ...loan })).reverse();
	}
	overdue(asOf: string): OverdueRow[] {
		validDay(asOf);
		return this.#loans
			.filter((loan) => isOverdue(loan, asOf))
			.sort((a, b) => compareText(a.dueOn, b.dueOn))
			.map((loan) => ({
				loanId: loan.id,
				itemName: this.#items.find((item) => item.id === loan.itemId)?.name ?? '',
				borrower: loan.borrower,
				dueOn: loan.dueOn
			}));
	}
	forItem(itemId: string): Equipment | undefined {
		const item = this.#items.find((row) => row.id === itemId);
		const open = this.#loans.filter((loan) => loan.itemId === itemId && loan.returnedOn === '');
		return item && new Equipment(item, open);
	}
	forLoan(loanId: string): Equipment | undefined {
		const loan = this.#loans.find((row) => row.id === loanId);
		return loan && this.forItem(loan.itemId);
	}
	save(equipment: Equipment): Loan {
		const change = equipment.pendingChange();
		let saved = change.loan;
		if (change.kind === 'open') {
			saved = { ...change.loan, id: loanId(this.#loans.length + 1) };
			this.#loans.unshift(saved);
		} else {
			this.#loans = this.#loans.map((loan) => (loan.id === saved.id ? saved : loan));
			const { repair } = change;
			if (repair) this.#items = this.#items.map((item) => (item.id === repair.id ? repair : item));
		}
		equipment.markSaved(saved);
		return { ...saved };
	}
}

export function seedItems(): Item[] {
	return [
		{ id: 'laptop-1', name: 'ThinkPad X1', kind: 'laptop', needsRepair: false },
		{ id: 'laptop-2', name: 'MacBook Air', kind: 'laptop', needsRepair: false },
		{ id: 'laptop-3', name: 'Dell XPS 13', kind: 'laptop', needsRepair: false },
		{ id: 'camera-1', name: 'Sony A7 IV', kind: 'camera', needsRepair: false },
		{ id: 'camera-2', name: 'Canon R6', kind: 'camera', needsRepair: false },
		{ id: 'camera-3', name: 'Fujifilm X-T5', kind: 'camera', needsRepair: false },
		{ id: 'camera-4', name: 'GoPro Hero 12', kind: 'camera', needsRepair: true },
		{ id: 'phone-1', name: 'Pixel 8', kind: 'phone', needsRepair: true },
		{ id: 'phone-2', name: 'iPhone 15', kind: 'phone', needsRepair: false }
	];
}
export function seedLoans(): Loan[] {
	const loan = (id: string, itemId: string, borrower: string, outOn: string, dueOn: string) => ({
		id,
		itemId,
		borrower,
		outOn,
		dueOn,
		returnedOn: ''
	});
	return [
		{ ...loan('L001', 'laptop-3', 'Ana', '2026-09-01', '2026-09-08'), returnedOn: '2026-09-07' },
		loan('L002', 'laptop-1', 'Ben', '2026-09-02', '2026-09-09'),
		loan('L003', 'camera-2', 'Cho', '2026-09-03', '2026-09-10'),
		loan('L004', 'camera-3', 'Dev', '2026-09-03', '2026-09-10'),
		loan('L005', 'phone-2', 'Eli', '2026-09-05', '2026-09-12'),
		loan('L006', 'camera-4', 'Fay', '2026-09-06', '2026-09-10'),
		loan('L007', 'camera-1', 'Gus', '2026-09-10', '2026-09-20'),
		loan('L008', 'laptop-2', 'Hal', '2026-09-13', '2026-09-14')
	];
}
export function seedStore(): Store {
	return new Store(seedItems(), seedLoans());
}

export function runExample(): string[] {
	const ids = (rows: readonly OverdueRow[]) => rows.map((row) => row.loanId).join(' ');
	const lines = ['overdue on 2026-09-14'];
	for (const alternative of alternatives) {
		const store = seedStore();
		const rows = openDesk(alternative, store).overdue('2026-09-14');
		const { storeCalls, rowsLoaded } = store.stats();
		lines.push(
			`${alternative}: ${ids(rows)} (store calls ${storeCalls}, rows loaded ${rowsLoaded})`
		);
	}
	lines.push('import checks out camera-2 again');
	for (const alternative of alternatives) {
		const store = seedStore();
		const row = { itemId: 'camera-2', borrower: 'Import', today: '2026-09-14', days: 7 };
		const [result] = importLoans([row], importWriters[alternative](store));
		const open = store.loans({ where: (loan) => loan.itemId === 'camera-2' && !loan.returnedOn });
		const outcome = result.loan ? `created ${result.loan.id}` : result.error;
		lines.push(`${alternative}: ${outcome}, open loans ${open.length}`);
	}
	lines.push(
		`fake on 2026-09-14: ${ids(new FakeEquipmentLoans(seedItems(), seedLoans()).overdue('2026-09-14'))}`
	);
	return lines;
}

for (const line of runExample()) console.log(line);