DI ports

// @acme/reviews-server — src/lib/review-moderation.port.ts
import type { CreateReviewDto } from './create-review.dto';

export const REVIEW_MODERATION = Symbol('REVIEW_MODERATION');

export interface ReviewModeration {
    /** Return a reason to hold the review, or null to accept it. */
    hold(workspaceId: string, review: CreateReviewDto): Promise<string | null>;
}

// @acme/reviews-server — reviews.service.ts
import { Inject, Injectable, Optional, UnprocessableEntityException } from '@nestjs/common';
import type { CreateReviewDto } from './create-review.dto';
import { REVIEW_MODERATION, type ReviewModeration } from './review-moderation.port';

@Injectable()
export class ReviewsService {
    constructor(
        @Optional()
        @Inject(REVIEW_MODERATION)
        private readonly moderation?: ReviewModeration
    ) {}

    async create(workspaceId: string, dto: CreateReviewDto) {
        const reason = await this.moderation?.hold(workspaceId, dto);
        if (reason) throw new UnprocessableEntityException(reason);
        // …insert
    }
}

// @acme/moderation-server — moderation.module.ts
import { Module, type DynamicModule } from '@nestjs/common';
import { REVIEW_MODERATION } from '@acme/reviews-server';
import { BannedWordsModeration } from './banned-words.moderation';

@Module({})
export class ModerationModule {
    static forRoot(): DynamicModule {
        return {
            module: ModerationModule,
            global: true, // how the binding reaches ReviewsService
            providers: [
                BannedWordsModeration,
                { provide: REVIEW_MODERATION, useExisting: BannedWordsModeration }
            ],
            exports: [REVIEW_MODERATION]
        };
    }
}

// packages/media/server/src/lib/media.module.ts
MediaAssetResolverQuery,
{ provide: MEDIA_ASSET_RESOLVER, useExisting: MediaAssetResolverQuery }

// @acme/reviews-server — open-reviews.publish-guard.ts
import { Injectable } from '@nestjs/common';
import type {
    ContentPublishGuard,
    ContentPublishGuardContext,
    PublishVerdict
} from '@orthacms/content-server';
import { InjectDatabase, type Database } from '@orthacms/database';
import { and, count, eq, isNull } from 'drizzle-orm';
import { reviews } from './schema';

@Injectable()
export class OpenReviewsPublishGuard implements ContentPublishGuard {
    constructor(@InjectDatabase() private readonly db: Database) {}

    async check({ entryId, workspaceId }: ContentPublishGuardContext): Promise<PublishVerdict> {
        const [{ open }] = await this.db
            .select({ open: count() })
            .from(reviews)
            .where(
                and(
                    eq(reviews.workspaceId, workspaceId),
                    eq(reviews.entryId, entryId),
                    isNull(reviews.resolvedAt)
                )
            );
        if (open === 0) return { allowed: true };
        return {
            allowed: false,
            status: 409,
            code: 'open_reviews',
            message: `${open} review(s) on this entry are still open.`
        };
    }
}

// reviews.module.ts — providers
import { contentPublishGuardRegistrar } from '@orthacms/content-server';

providers: [
    OpenReviewsPublishGuard,
    // Registers on bootstrap; injects the registry optionally, so the app
    // still boots without ContentPlugin
    contentPublishGuardRegistrar('reviews', OpenReviewsPublishGuard)
]

// 409 Conflict
{ "statusCode": 409, "code": "open_reviews", "message": "2 review(s) on this entry are still open." }