Backend architektúra

// packages/db/courses/schema.ts
import { z } from 'zod';
import { ObjectId } from 'mongodb';
 
export const CourseSchema = z.object({
  _id: z.instanceof(ObjectId),
  slug: z.string().min(3).max(80).regex(/^[a-z0-9-]+$/),
  title: z.string().min(3),
  description: z.string(),
  priceCents: z.number().int().positive(),  // 12000 = 120,00 €
  currency: z.literal('EUR'),
  state: z.enum(['draft', 'published', 'archived']),
  levels: z.array(z.instanceof(ObjectId)),       // refs na Levels collection
  courseTestId: z.instanceof(ObjectId).optional(),
  courseTestRequired: z.boolean(),
  version: z.number().int().positive(),
  createdAt: z.date(),
  updatedAt: z.date(),
});
export type Course = z.infer<typeof CourseSchema>;

// packages/db/courses/repository.ts
import { getDb } from '../client';
import { CourseSchema, type Course } from './schema';
 
export async function findCourseBySlug(slug: string): Promise<Course | null> {
  const db = await getDb();
  const doc = await db.collection('courses').findOne({ slug, state: 'published' });
  if (!doc) return null;
  return CourseSchema.parse(doc);
}

// apps/app/lib/services/enrollment-service.ts
import { withTransaction } from '@clubup/db';
 
export async function enrollStudent(args: {
  studentId: string;
  courseId: string;
  paymentId?: string;
  reason: 'paid' | 'admin_grant' | 'sponsor';
}) {
  return withTransaction(async (session) => {
    const course = await findCourseById(args.courseId, { session });
    if (!course) throw new NotFound('course');
 
    const existing = await findEnrollment(args, { session });
    if (existing) return existing;  // idempotent
 
    const enrollment = await createEnrollment({
      ...args,
      enrolledAt: new Date(),
      state: 'active',
    }, { session });
 
    // Pre-allocate progress so vsetkymi castami kurzu
    await initializeProgress({
      enrollmentId: enrollment._id,
      courseId: course._id,
      studentId: args.studentId,
    }, { session });
 
    return enrollment;
  });
}

// apps/app/lib/services/progress-service.ts
export async function markPartCompleted(args: {
  enrollmentId: ObjectId;
  partId: ObjectId;
}) {
  return withTransaction(async (session) => {
    const progress = await findProgressByEnrollment(args.enrollmentId, { session });
    const part = await findPart(args.partId, { session });
 
    // 1. Update PartProgress.state -> completed
    await updatePartProgress(args.enrollmentId, args.partId, { state: 'completed', completedAt: new Date() }, { session });
 
    // 2. Re-evaluate downstream parts (prerequisites)
    await unlockDownstreamParts(args.enrollmentId, part.moduleId, args.partId, { session });
 
    // 3. Re-evaluate module completion
    const moduleReady = await checkModuleCompletion(args.enrollmentId, part.moduleId, { session });
    if (moduleReady) {
      await recordModuleCompletion(args.enrollmentId, part.moduleId, { session });
 
      // 4. Re-evaluate level completion
      const levelReady = await checkLevelCompletion(args.enrollmentId, part.levelId, { session });
      if (levelReady) {
        await recordLevelCompletion(args.enrollmentId, part.levelId, { session });
 
        // 5. Trigger intermediate certificate, ak je nastavené
        await maybeIssueIntermediateCertificate(args.enrollmentId, part.levelId, { session });
 
        // 6. Re-evaluate course completion
        const courseReady = await checkCourseCompletion(args.enrollmentId, part.courseId, { session });
        if (courseReady) {
          await markCourseCompleted(args.enrollmentId, { session });
          await issueFinalCertificate(args.enrollmentId, { session });  // async via Inngest
        }
      }
    }
  });
}

// 24-pay webhook handler
export async function POST(req: Request) {
  const body = await req.text();
  const signature = req.headers.get('x-24pay-signature');
 
  if (!verifyHmac(body, signature, process.env.PAYMENT_24PAY_SECRET)) {
    return new Response('invalid signature', { status: 401 });
  }
 
  const event = parse24PayEvent(body);
 
  // Idempotency: 24-pay môže webhook zopakovať
  await withTransaction(async (session) => {
    const existing = await findWebhookEvent(event.eventId, { session });
    if (existing) return;
 
    await recordWebhookEvent(event, { session });
    await processPaymentEvent(event, { session });  // update Order, create Enrollment
  });
 
  return new Response('ok', { status: 200 });
}

// packages/auth/rbac.ts
export type Role = 'student' | 'instructor' | 'content_manager' | 'admin';
 
export const PERMISSIONS = {
  'course.read.published':  ['student', 'instructor', 'content_manager', 'admin'],
  'course.read.draft':      ['content_manager', 'admin'],
  'course.create':          ['content_manager', 'admin'],
  'course.update':          ['content_manager', 'admin'],
  'course.publish':         ['admin'],
  'course.delete':          ['admin'],
  'level.create':           ['content_manager', 'admin'],
  'topic.create':           ['content_manager', 'admin'],
  'module.create':          ['content_manager', 'admin'],
  'part.create':            ['content_manager', 'admin'],
  'test.create':            ['content_manager', 'admin'],
  'question.create':        ['content_manager', 'admin'],
  'enrollment.read.own':    ['student', 'instructor', 'content_manager', 'admin'],
  'enrollment.read.all':    ['admin'],
  'enrollment.create':      ['admin'],  // manuálne udelenie
  'order.read.own':         ['student', 'admin'],
  'order.read.all':         ['admin'],
  'certificate.issue':      ['admin'],
  'webinar.create':         ['instructor', 'content_manager', 'admin'],
  // ...
} as const;
 
export function can(role: Role, permission: keyof typeof PERMISSIONS): boolean {
  return PERMISSIONS[permission].includes(role);
}

import { requireRole } from '@clubup/auth';
 
export async function deleteCourse(courseId: string) {
  await requireRole('admin');
  // ...
}

import { Ratelimit } from '@upstash/ratelimit';
import { Redis } from '@upstash/redis';
 
const limiter = new Ratelimit({
  redis: Redis.fromEnv(),
  limiter: Ratelimit.slidingWindow(20, '1 m'),
});
 
export async function POST(req: Request) {
  const ip = req.headers.get('x-forwarded-for') ?? 'unknown';
  const { success } = await limiter.limit(`contact:${ip}`);
  if (!success) return new Response('rate limited', { status: 429 });
  // ...
}

await audit({
  actor: session.user.sportupPersonId,
  actorRole: session.user.role,
  action: 'course.delete',
  target: { type: 'course', id: courseId },
  diff: { before: existing, after: null },
  ip: req.headers.get('x-forwarded-for'),
  userAgent: req.headers.get('user-agent'),
  timestamp: new Date(),
});

// packages/db/errors.ts
export class DomainError extends Error {
  constructor(public code: string, message: string) {
    super(message);
  }
}
 
export class NotFound extends DomainError {
  constructor(public resource: string) {
    super('not_found', `${resource} not found`);
  }
}
 
export class ValidationError extends DomainError {
  constructor(public errors: unknown) {
    super('validation', 'validation failed');
  }
}
 
export class ConflictError extends DomainError {
  constructor(reason: string) {
    super('conflict', reason);
  }
}

try {
  // ...
} catch (e) {
  if (e instanceof NotFound) return Response.json({ error: e.code }, { status: 404 });
  if (e instanceof ValidationError) return Response.json({ error: e.code, details: e.errors }, { status: 422 });
  if (e instanceof ConflictError) return Response.json({ error: e.code, reason: e.message }, { status: 409 });
  Sentry.captureException(e);
  return Response.json({ error: 'internal' }, { status: 500 });
}