# Semana 13: mensajería, eventos y consistencia. Una aplicación pequeña de
# venta de entradas con outbox, relay y consumidores sobre NATS JetStream, y
# un agregado con event sourcing. Se usa dentro del contenedor del curso.
#
#   make                 crea la base de datos arq_w13 y deja el stream W13_ORDERS vacío
#   make test            revisa los tipos (tsc) y corre las pruebas (test/*.test.ts, es/, ...)
#   make test-lab        las pruebas de lab/: fallan hasta que completen el laboratorio
#   make clean           borra las bases de datos, los streams y build/
#
# La escritura doble y la outbox (pasos 3 a 5 del laboratorio):
#   make dual-write N=100   N compras con errors/dual-write.ts, un proceso por compra
#   make outbox N=100       N compras con lab/outbox.ts
#   make relay              el relay, hasta Ctrl+C; make relay-once publica lo pendiente y termina
#   make counts             órdenes, filas de la outbox y eventos en el stream
# Variables: CRASH_BETWEEN=1 (o 0.5: la mitad de las veces), PUBLISH_FIRST=1,
# CRASH_AFTER_PUBLISH=1, RELAY_MSG_ID=1.
#
# Los consumidores (pasos 6 a 8):
#   make consumer C=points-naive   C puede ser points-naive, points o report
#   make status                    puntos, reporte y dead letters, al lado de las órdenes
#   make replay                    reconstruye el reporte desde el inicio del stream y compara
#   make info C=points             el estado de un consumer, con nats consumer info
# Variables: POISON_ORDER=3 (falla siempre con esa orden), MAX_DELIVER=3.
#
# Lo que JetStream garantiza, mostrado (demos/):
#   make worker C=shared           un proceso que lee con el consumer C y dice qué recibió
#   make demo-ack                  confirmar antes o después de procesar, con una caída en medio
#   make demo-order                el orden con uno y con tres procesos, y con un reintento
#   make demo-max-deliveries       cómo avisa el servidor que se agotaron las entregas
#   make demo-limits               un stream con límite: descartar lo viejo o rechazar lo nuevo
#
# Event sourcing y CQRS (Sesión B):
#   make es                        un agregado, su historia y su vista de lectura
#
# W13_IMPL=solution usa solution/ en vez de lab/ (si tienen esa carpeta).

N ?= 100
C ?= points
STREAM = W13_ORDERS
DB = arq_w13
# psql no avisa cuando la base de datos que se va a borrar todavía no existe.
PGOPTIONS = --client-min-messages=warning
export PGOPTIONS

TEST_ENV = W13_DB=$(DB)_test W13_STREAM=W13_TEST_ORDERS W13_SUBJECT_PREFIX=w13test.orders W13_LOG=off \
  REDELIVERY_DELAY_MS=100 ACK_WAIT_MS=1000
TESTS = "test/*.test.ts" "es/*.test.ts" "ordering/*.test.ts" "consensus/*.test.ts"

.PHONY: all db test test-lab test-db dual-write outbox relay relay-once counts consumer status replay info \
        worker demo-ack demo-order demo-max-deliveries demo-limits es clean

all: db

db:
	@psql -q -d postgres -c "DROP DATABASE IF EXISTS $(DB) WITH (FORCE)" -c "CREATE DATABASE $(DB)"
	@psql -q -d $(DB) -v ON_ERROR_STOP=1 -f db/schema.sql -f es/schema.sql
	@nats stream rm -f $(STREAM) >/dev/null 2>&1 || true
	@echo "Base de datos $(DB) recién creada; stream $(STREAM) borrado."

# Las pruebas usan su propia base de datos y su propio stream: no necesitan
# nada corriendo ni tocan los datos de los experimentos. Comparten la base de
# datos, así que los archivos corren uno después de otro.
test-db:
	@psql -q -d postgres -c "DROP DATABASE IF EXISTS $(DB)_test WITH (FORCE)" -c "CREATE DATABASE $(DB)_test"
	@psql -q -d $(DB)_test -v ON_ERROR_STOP=1 -f db/schema.sql -f es/schema.sql

# Si existe solution/, make test corre además las pruebas del laboratorio
# contra ella.
test: test-db
	tsc -p .
	$(TEST_ENV) node --test --test-concurrency=1 $(TESTS)
	@if [ -d solution ]; then \
	  echo "== las pruebas de lab/ con solution/"; \
	  $(TEST_ENV) W13_IMPL=solution node --test --test-concurrency=1 "lab/*.test.ts"; \
	fi

test-lab: test-db
	$(TEST_ENV) node --test --test-concurrency=1 "lab/*.test.ts"

dual-write:
	@bash tools/repeat.sh $(N) dual-write

outbox:
	@bash tools/repeat.sh $(N) outbox

relay:
	@node tools/relay.ts

relay-once:
	@node tools/relay.ts once

counts:
	@node tools/counts.ts

consumer:
	@node tools/consumer.ts $(C)

status:
	@node tools/status.ts

replay:
	@node tools/replay.ts

info:
	nats consumer info $(STREAM) $(C)

worker:
	@node tools/worker.ts $(C)

# Las demostraciones usan su propio stream, W13_DEMO, y lo borran al terminar.
DEMO_ENV = W13_STREAM=W13_DEMO W13_SUBJECT_PREFIX=w13demo.orders ACK_WAIT_MS=1000 REDELIVERY_DELAY_MS=300

demo-ack:
	@$(DEMO_ENV) node demos/ack-timing.ts

demo-order:
	@$(DEMO_ENV) W13_LOG=off node demos/ordering.ts

demo-max-deliveries:
	@$(DEMO_ENV) W13_LOG=off node demos/max-deliveries.ts

demo-limits:
	@node demos/limits.ts

es:
	@node es/main.ts

clean:
	@psql -q -d postgres -c "DROP DATABASE IF EXISTS $(DB) WITH (FORCE)" -c "DROP DATABASE IF EXISTS $(DB)_test WITH (FORCE)"
	@for s in $(STREAM) W13_TEST_ORDERS W13_DEMO; do nats stream rm -f $$s >/dev/null 2>&1 || true; done
	rm -rf build
