插件后端工具与封装文档

import { ExtensionWebController } from "@buildingai/core/decorators";

import { BaseController } from "@buildingai/base";
import { ExtensionWebController } from "@buildingai/core/decorators";
import { Public } from "@buildingai/decorators/public.decorator";
import { UUIDValidationPipe } from "@buildingai/pipe/param-validate.pipe";
import { Get, Param, Query } from "@nestjs/common";

@ExtensionWebController("article")
export class ArticleWebController extends BaseController {
    constructor(private readonly articleService: ArticleService) {
        super();
    }

    @Get()
    @Public()
    async findAll(@Query() query: QueryArticleDto) {
        return this.articleService.list(query);
    }

    @Get(":id")
    @Public()
    async findOne(@Param("id", UUIDValidationPipe) id: string) {
        return this.articleService.findOneById(id);
    }
}

import { ExtensionConsoleController } from "@buildingai/core/decorators";

import { BaseController } from "@buildingai/base";
import { ExtensionConsoleController } from "@buildingai/core/decorators";
import { Playground } from "@buildingai/decorators/playground.decorator";
import { type UserPlayground } from "@buildingai/db";
import { UUIDValidationPipe } from "@buildingai/pipe/param-validate.pipe";
import { Body, Delete, Get, Param, Post, Query } from "@nestjs/common";

@ExtensionConsoleController("article", "文章管理")
export class ArticleController extends BaseController {
    constructor(private readonly articleService: ArticleService) {
        super();
    }

    @Post()
    async create(@Body() dto: CreateArticleDto, @Playground() user: UserPlayground) {
        return this.articleService.createArticle(dto, user.id);
    }

    @Get()
    async findAll(@Query() query: QueryArticleDto) {
        return this.articleService.list(query);
    }

    @Delete(":id")
    async remove(@Param("id", UUIDValidationPipe) id: string) {
        await this.articleService.delete(id);
        return { success: true };
    }
}

import { ExtensionEntity } from "@buildingai/core/decorators";

import { ExtensionEntity } from "@buildingai/core/decorators";
import {
    Column,
    CreateDateColumn,
    PrimaryGeneratedColumn,
    UpdateDateColumn,
} from "@buildingai/db/typeorm";

@ExtensionEntity()
export class Article {
    @PrimaryGeneratedColumn("uuid")
    id: string;

    @Column({ length: 200, comment: "文章标题" })
    title: string;

    @Column({ type: "text", nullable: true, comment: "摘要" })
    summary?: string;

    @CreateDateColumn()
    createdAt: Date;

    @UpdateDateColumn()
    updatedAt: Date;
}

import { BaseController } from "@buildingai/base";

import { BaseController } from "@buildingai/base";

export class ArticleController extends BaseController {
    async list(dto: QueryArticleDto) {
        this.logger.log("query article list");
        return this.articleService.list(dto);
    }
}

{
    items: T[];
    total: number;
    page: number;
    pageSize: number;
    totalPages: number;
}

import { BaseService } from "@buildingai/base";

import { BaseService } from "@buildingai/base";
import { InjectRepository } from "@buildingai/db/@nestjs/typeorm";
import { Repository } from "@buildingai/db/typeorm";
import { HttpErrorFactory } from "@buildingai/errors";
import { Injectable } from "@nestjs/common";

import { Article } from "../../../db/entities/article.entity";
import { CreateArticleDto, QueryArticleDto } from "../dto";

@Injectable()
export class ArticleService extends BaseService<Article> {
    constructor(
        @InjectRepository(Article)
        private readonly articleRepository: Repository<Article>,
    ) {
        super(articleRepository);
    }

    async createArticle(dto: CreateArticleDto) {
        return this.create(dto);
    }

    async list(query: QueryArticleDto) {
        const where = query.title ? this.ilike("title", query.title) : {};

        return this.paginate(query, {
            where,
            order: { createdAt: "DESC" },
        });
    }

    async publish(id: string) {
        const article = await this.findOneById(id);

        if (!article) {
            throw HttpErrorFactory.notFound("文章不存在");
        }

        return this.updateById(id, { status: "published" });
    }
}

return this.findOneById(id, {
    relations: ["author"],
    includeFields: ["id", "title", "author.id", "author.nickname"] as const,
});

import { PaginationDto } from "@buildingai/dto";

import { PaginationDto } from "@buildingai/dto";
import { IsOptional, IsString, IsUUID } from "class-validator";

export class QueryArticleDto extends PaginationDto {
    @IsOptional()
    @IsString()
    title?: string;

    @IsOptional()
    @IsUUID()
    categoryId?: string;
}

import { UUIDValidationPipe } from "@buildingai/pipe/param-validate.pipe";

import { Get, Param } from "@nestjs/common";

@Get(":id")
async findOne(@Param("id", UUIDValidationPipe) id: string) {
    return this.articleService.findOneById(id);
}

import { Public } from "@buildingai/decorators/public.decorator";

@Get("published")
@Public()
async getPublished() {
    return this.articleService.getPublishedArticles();
}

import { Playground } from "@buildingai/decorators/playground.decorator";

import { type UserPlayground } from "@buildingai/db";

@Post()
async create(@Body() dto: CreateArticleDto, @Playground() user: UserPlayground) {
    return this.articleService.createArticle(dto, user.id);
}

async create(@Playground("id") userId: string) {
    return userId;
}

import { BuildFileUrl } from "@buildingai/decorators";

@Get(":id")
@BuildFileUrl(["cover", "author.avatar", "items.*.thumbnail"])
async findOne(@Param("id", UUIDValidationPipe) id: string) {
    return this.articleService.findOneById(id);
}

import { SkipTransform } from "@buildingai/decorators";

@Get("raw")
@SkipTransform()
async raw() {
    return "plain text";
}

import { HttpErrorFactory } from "@buildingai/errors";

if (!article) {
    throw HttpErrorFactory.notFound("文章不存在");
}

if (!category) {
    throw HttpErrorFactory.badRequest("栏目不存在");
}

import { ApplicationError, HttpError, HttpStatus } from "@buildingai/errors";

import { InjectRepository, TypeOrmModule } from "@buildingai/db/@nestjs/typeorm";
import { Repository } from "@buildingai/db/typeorm";

import { TypeOrmModule } from "@buildingai/db/@nestjs/typeorm";
import { Module } from "@nestjs/common";

import { Article } from "../../db/entities/article.entity";
import { ArticleController } from "./controllers/console/article.controller";
import { ArticleWebController } from "./controllers/web/article.web.controller";
import { ArticleService } from "./services/article.service";

@Module({
    imports: [TypeOrmModule.forFeature([Article])],
    controllers: [ArticleController, ArticleWebController],
    providers: [ArticleService],
    exports: [ArticleService],
})
export class ArticleModule {}

constructor(
    @InjectRepository(Article)
    private readonly articleRepository: Repository<Article>,
) {}

import {
    Column,
    CreateDateColumn,
    In,
    Like,
    ManyToOne,
    PrimaryGeneratedColumn,
    UpdateDateColumn,
} from "@buildingai/db/typeorm";

import { User } from "@buildingai/db/entities";

import { User } from "@buildingai/db/entities";
import { JoinColumn, ManyToOne } from "@buildingai/db/typeorm";

@ManyToOne(() => User, { nullable: true })
@JoinColumn({ name: "authorId" })
author?: User;

import { PublicUserService } from "@buildingai/extension-sdk";

constructor(private readonly userService: PublicUserService) {}

async attachAuthor(authorId: string) {
    const author = await this.userService.findUserById(authorId);

    if (!author) {
        throw HttpErrorFactory.notFound("作者不存在");
    }

    return author;
}

import { AiPublicModule, PublicAiModelService } from "@buildingai/extension-sdk";

import { AiPublicModule } from "@buildingai/extension-sdk";
import { Module } from "@nestjs/common";

@Module({
    imports: [AiPublicModule],
    providers: [GenerateService],
    exports: [GenerateService],
})
export class GenerateModule {}

import { PublicAiModelService } from "@buildingai/extension-sdk";

constructor(private readonly aiModelService: PublicAiModelService) {}

import { ExtensionBillingModule, ExtensionBillingService } from "@buildingai/extension-sdk";

import { ExtensionBillingModule } from "@buildingai/extension-sdk";
import { Module } from "@nestjs/common";

@Module({
    imports: [ExtensionBillingModule],
    providers: [GenerateService],
    exports: [GenerateService],
})
export class GenerateModule {}

import { ExtensionBillingService } from "@buildingai/extension-sdk";

constructor(private readonly billingService: ExtensionBillingService) {}

import type { ExtensionPowerDeductionOptions } from "@buildingai/extension-sdk";

import { buildWhere } from "@buildingai/utils";

import { Like } from "@buildingai/db/typeorm";
import { buildWhere } from "@buildingai/utils";

const where = buildWhere<Article>({
    title: query.title ? Like(`%${query.title}%`) : undefined,
    categoryId: query.categoryId,
    status: query.status,
});

return this.paginate(query, { where });

import {
    asArray,
    asBoolean,
    asDate,
    asDefined,
    asError,
    asJson,
    asNumber,
    asObject,
    asString,
} from "@buildingai/utils";

import { joinPaths, joinRouterPaths, validatePath } from "@buildingai/utils";

import { parseExtensionIdentifier, parsePackageName } from "@buildingai/utils";

import { checkVersionCompatibility, decryptValue, maskSensitiveValue } from "@buildingai/utils";

import { createResolvablePromise, DelayedPromise, StreamUtils } from "@buildingai/utils";

import { extractFilesFromMessageContent, extractTextFromMessageContent } from "@buildingai/utils";

import { Body, Delete, Get, Param, Patch, Post, Query } from "@nestjs/common";
import { Injectable, Module } from "@nestjs/common";