Performance: Avoid External API calls within Transactions

[wp99cp]

conveniat-webpage/src/features/schedule/api/schedule-router.ts

Lines 183 to 188 in 472d3aa

	const payload = await getPayload({ config });
	const course = await payload.findByID({
	collection: 'camp-schedule-entry',
	id: courseId,
	depth: 0,
	});

see https://www.prisma.io/docs/orm/prisma-client/queries/transactions#overview

[wp99cp]

Some inspiration:

import { Effect, Layer, Context } from "effect";

// 1. Define distinct errors (Self-documenting code)
class CourseFullError { readonly _tag = "CourseFullError" }
class EnrollmentConflictError { readonly _tag = "EnrollmentConflictError" }
class DatabaseLockError { readonly _tag = "DatabaseLockError" }

// 2. The Logic
const enrollUserProgram = (input: { courseId: string, userId: string }) => 
  Effect.gen(function* (_) {
    // A. Dependencies (Injected, making testing easy)
    const prisma = yield* _(PrismaService);
    const payload = yield* _(PayloadService);

    // B. Parallel fetching (Effect makes this safer than Promise.all)
    // We fetch the course and the user's existing enrollments at the same time
    const [course, userEnrollments] = yield* _(
      Effect.all([
        payload.getCourse(input.courseId),
        prisma.getUserEnrollments(input.userId)
      ], { concurrency: "unbounded" })
    );

    // C. Validation (Short circuiting)
    if (!course.enable_enrolment) {
      return yield* _(Effect.fail(new TRPCError({ code: 'BAD_REQUEST' })));
    }

    // D. The Transactional Core
    // Effect.scoped automatically handles opening/closing resources (like locks)
    yield* _(
      prisma.transaction(async (tx) => {
        
        // 1. Check Capacity (Atomic Logic)
        const currentCount = await tx.enrollment.count({ ... });
        if (currentCount >= course.max) {
           // We 'fail' the effect, which breaks the transaction flow
           return yield* _(Effect.fail(new CourseFullError()));
        }

        // 2. Check Conflicts (Pure Logic)
        const conflicts = checkTimeConflicts(course, userEnrollments);
        if (conflicts) {
           return yield* _(Effect.fail(new EnrollmentConflictError()));
        }

        // 3. Perform Write
        await tx.enrollment.create({ ... });
      })
    );

    // E. Return success
    return { success: true };
  }).pipe(
    // F. The "Magic": Structured Error Handling
    // If any of the above failed, we map them to TRPC errors here at the edge.
    Effect.catchTags({
      CourseFullError: () => Effect.fail(new TRPCError({ message: "Full" })),
      EnrollmentConflictError: () => Effect.fail(new TRPCError({ message: "Conflict" })),
      DatabaseLockError: () => Effect.retry({ times: 3 }) // Auto-retry locks!
    })
  );

With wide logging (see #545)

import { Effect, FiberRef, Layer, Logger, LogLevel } from "effect";

// 1. The Accumulator: Holds all data for this request
// We start with an empty object.
const RequestContext = FiberRef.unsafeMake<Record<string, unknown>>({});

// 2. Helper to add data to the "Wide Event" without logging yet
export const logContext = (key: string, value: unknown) => 
  FiberRef.update(RequestContext, (ctx) => ({ ...ctx, [key]: value }));

// 3. The "Wide Logger" Middleware
// This wraps your entire API endpoint. It initializes the context,
// runs your handler, and guarantees ONE log line at the end.
export const useWideLogging = <A, E, R>(effect: Effect.Effect<A, E, R>) => 
  Effect.gen(function* (_) {
    const startTime = Date.now();
    
    // Run the actual business logic
    // We use 'exit' to catch both Success and Failure without throwing
    const exit = yield* _(Effect.exit(effect));

    const duration = Date.now() - startTime;
    const context = yield* _(FiberRef.get(RequestContext));

    // Construct the Final Canonical Event
    const wideEvent = {
      ...context,
      duration_ms: duration,
      success: exit._tag === "Success",
      // If it failed, add the error details
      error: exit._tag === "Failure" ? String(exit.cause) : undefined,
    };

    // Emit the SINGLE log line (Structured JSON)
    if (exit._tag === "Failure") {
      yield* _(Effect.logError(JSON.stringify(wideEvent)));
      // Propagate error so HTTP layer knows to send 500/400
      return yield* _(exit); 
    } else {
      yield* _(Effect.logInfo(JSON.stringify(wideEvent)));
      return exit.value;
    }
  });

// ... imports ...

const enrollUserProgram = (input: { courseId: string, userId: string }) => 
  Effect.gen(function* (_) {
    // 1. Start building the context immediately
    yield* _(logContext("event", "course_enrollment"));
    yield* _(logContext("user_id", input.userId));
    yield* _(logContext("course_id", input.courseId));

    const prisma = yield* _(PrismaService);
    
    // ... Fetch Logic ...
    const course = yield* _(payload.getCourse(input.courseId));
    
    // Add high-cardinality data as we discover it
    yield* _(logContext("course_title", course.title));
    yield* _(logContext("course_capacity", course.max));

    if (!course.enable_enrolment) {
       // We add the "why" before failing
       yield* _(logContext("failure_reason", "enrollment_disabled"));
       return yield* _(Effect.fail(new TRPCError({ code: 'BAD_REQUEST' })));
    }

    // ... Transaction Logic ...
    yield* _(
      prisma.transaction(async (tx) => {
        const currentCount = await tx.enrollment.count({ ... });
        
        // Record metrics that are useful for debugging race conditions later
        yield* _(logContext("participants_at_start", currentCount));

        if (currentCount >= course.max) {
           yield* _(logContext("failure_reason", "capacity_full"));
           return yield* _(Effect.fail(new CourseFullError()));
        }

        // ... Create Enrollment ...
      })
    );

    yield* _(logContext("status", "enrolled"));
    return { success: true };
  }).pipe(
    // Wrap with our Wide Logger
    useWideLogging
  );

Gives You Logs of the form

{
  "event": "course_enrollment",
  "user_id": "u-123",
  "course_id": "c-999",
  "course_capacity": 20,
  "participants_at_start": 20,
  "failure_reason": "capacity_full",
  "duration_ms": 45,
  "success": false
}