Data Access Layer y DTOs en Next.js

Data Access Layer y DTOs en Next.js | Nicolás Garzón

Texto

Page / Action / Route Handler
            ↓
Data Access Layer
├─ session/principal
├─ authorization
├─ query or transaction
├─ cache policy
├─ mapping
└─ typed result / DTO
            ↓
Database or external service

TypeScript

// page A
const order = await db.order.findUnique({ where: { id } });

// action B
const order = await db.order.findFirst({ where: { id, userId } });

// route C
const order = await db.order.findUnique({ include: { customer: true } });

TypeScript

type OrderRecord = {
  id: string;
  organizationId: string;
  customerId: string;
  internalCost: number;
  fraudScore: number;
  status: string;
  total: number;
  createdAt: Date;
};

TypeScript

function toOrderView(order: OrderRecord): OrderView {
  return {
    id: order.id,
    status: parseOrderStatus(order.status),
    total: order.total,
    createdAt: order.createdAt.toISOString(),
  };
}

TypeScript

export const getOrderForCurrentUser = cache(
  async (orderId: string): Promise<OrderView | null> => {
    const session = await verifySession();
    if (!session) return null;

    const order = await db.order.findFirst({
      where: {
        id: orderId,
        organizationId: session.organizationId,
        organization: {
          members: { some: { userId: session.userId } },
        },
      },
      select: {
        id: true,
        status: true,
        total: true,
        createdAt: true,
      },
    });

    return order ? toOrderView(order as OrderRecord) : null;
  },
);

TypeScript

const result = await getOrder(input);
if (result.status === "unauthenticated") redirect("/login");
if (result.status === "notFound") notFound();
return <OrderDetails order={result.order} />;

TypeScript

export async function cancelOrder(input: {
  orderId: string;
  expectedVersion: number;
}): Promise<CancelOrderResult> {
  const session = await requireSession();

  return db.$transaction(async (tx) => {
    const order = await tx.order.findFirst({
      where: {
        id: input.orderId,
        organizationId: session.organizationId,
      },
    });

    if (!order) return { status: "notFound" };
    if (!canCancelOrder(session, order)) return { status: "forbidden" };
    if (order.version !== input.expectedVersion) return { status: "conflict" };

    await tx.order.update({
      where: { id: order.id },
      data: { status: "cancelled", version: { increment: 1 } },
    });

    return { status: "success", orderId: order.id };
  });
}

TypeScript

export async function getPublicProduct(slug: string) {
  "use cache";
  cacheLife("hours");
  cacheTag(`product:${slug}`);
  return toPublicProductView(await repository.findBySlug(slug));
}