后端工具与封装开发文档

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 { InjectRepository } from "@buildingai/db/@nestjs/typeorm";
import { Repository } from "@buildingai/db/typeorm";
import { Injectable } from "@nestjs/common";

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

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

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

    return this.paginate(dto, {
        where,
        relations: ["category", "author"],
        order: { sort: "DESC", createdAt: "DESC" },
        select: {
            author: {
                id: true,
                avatar: true,
                nickname: true,
            },
        },
    });
}

return this.findOneById(id, {
    relations: ["author"],
    excludeFields: ["author.password", "author.salt"] as const,
});

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

const qb = this.repository
    .createQueryBuilder("article")
    .leftJoinAndSelect("article.category", "category")
    .where("article.title ILIKE :keyword", { keyword: `%${dto.keyword}%` })
    .orderBy("article.createdAt", "DESC");

return this.paginateQueryBuilder(qb, dto, ["author.password"]);

await this.withTransaction(async (manager) => {
    await this.updateById(id, dto, { entityManager: manager });

    const repo = manager.getRepository(ArticleLog);
    await repo.save(repo.create({ articleId: id, action: "update" }));
});

import { LockType } from "@buildingai/base/services/base.service";

await this.updateById(id, dto, {
    lock: {
        type: LockType.PESSIMISTIC_WRITE,
        retryCount: 3,
        retryDelay: 100,
    },
});

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

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

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

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

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

if (!entity) {
    throw HttpErrorFactory.notFound("记录不存在");
}

if (!canUpdate) {
    throw HttpErrorFactory.forbidden("无权操作");
}

if (!dto.name) {
    throw HttpErrorFactory.badRequest("名称不能为空");
}

import { WebController } from "@common/decorators";

@WebController("article")
export class ArticleWebController {
    @Get()
    list() {}
}

@WebController({ path: "public", skipAuth: true })
export class PublicController {}

import { ConsoleController, Permissions } from "@common/decorators";

@ConsoleController("role", "角色管理")
export class RoleController extends BaseController {
    @Get()
    @Permissions({ code: "role:list", name: "角色列表", action: "查看" })
    findAll() {
        return this.roleService.findAll();
    }
}

@ConsoleController(
    {
        path: "settings",
        skipAuth: false,
        skipPermissionCheck: true,
    },
    "系统设置",
)
export class SettingsController {}

@OpenApiController("chat-messages")
export class OpenChatController {
    @Post()
    chat() {}
}

@Permissions({
    code: "user:create",
    name: "创建用户",
    action: "创建",
    group: "user",
    groupName: "用户管理",
})
@Post()
create() {}

@AgentPublicAccess({
    route: "/public/agents/:id/chat",
    targetPath: "/api/agents/:id/chat",
    method: "POST",
})
@Post(":id/chat")
chat() {}

@AgentApiKey()
@Post(":id/messages")
messages() {}

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

@Public()
@Get("config")
getPublicConfig() {}

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

@Post()
create(@Body() dto: CreateDto, @Playground() user: UserPlayground) {
    return this.service.create(dto, user.id);
}

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

@BuildFileUrl(["avatar", "cover", "author.avatar", "items.*.thumbnail"])
@Get()
list() {}

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

@SkipTransform()
@Post("webhook")
webhook() {
    return "success";
}

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

@SuperAdminOnly()
@Delete(":id")
removeSystemResource() {}

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

@ExtensionWebController("article")
export class ArticleWebController {
    @Get()
    list() {}
}

/{extensionIdentifier}/api/{path}

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

@ExtensionConsoleController("article", "文章管理")
export class ArticleController extends BaseController {}

/{extensionIdentifier}/console/{path}

{extensionIdentifier}@{path}

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

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

    @Column()
    title: string;
}

@MemberOnly({
    code: "simple-blog:advanced-export",
    name: "高级导出",
    description: "导出完整文章数据",
})
@Post("export")
exportAll() {}

import { TypeOrmModule } from "@buildingai/db/@nestjs/typeorm";
import { User } from "@buildingai/db/entities";
import { DataSource, Repository } from "@buildingai/db/typeorm";

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

import { BaseSeeder } from "@buildingai/db";

export class ArticleSeeder extends BaseSeeder {
    async run() {
        // seed data
    }
}

import { UploadModule, FileUploadService } from "@buildingai/core/modules";

@Module({
    imports: [UploadModule],
    providers: [MyService],
})
export class MyModule {}

import { CloudStorageModule, CloudStorageService } from "@buildingai/core/modules";

import { QueueModule, QueueService } from "@buildingai/core/modules";

@Module({
    imports: [QueueModule],
})
export class WorkerModule {
    constructor(private readonly queueService: QueueService) {}
}

import { AppBillingService, BillingModule } from "@buildingai/core/modules";

import { SecretModule, SecretService } from "@buildingai/core/modules";

import { ExtensionsService } from "@buildingai/core/modules";

import { ScheduleService } from "@buildingai/core";

import { CacheModule, CacheService, RedisModule, RedisService } from "@buildingai/cache";

@Module({
    imports: [RedisModule, CacheModule],
})
export class MyModule {}

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

const page = asNumber(query.page, 1);
const enabled = asBoolean(dto.enabled);
const tags = asArray(dto.tags);
const payload = asObject(dto.payload);
const type = asOneOf(input.type, ["web", "console"] as const, "web");

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

const where = buildWhere({
    title: keyword ? Like(`%${keyword}%`) : undefined,
    status,
});

const updatePayload = buildConditionalObject({
    nickname: dto.nickname,
    avatar: dto.avatar || undefined,
});

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

validatePath(pathSegment);
const route = joinRouterPaths("simple-blog", "console", "article");
const filePath = joinPaths(root, "storage", "uploads");

import { isDevelopment, isDisabled, isEnabled, isProduction } from "@buildingai/utils";

if (isEnabled(user.status)) {
}
if (isDisabled(config.status)) {
}
isDevelopment(() => this.logger.debug("debug only"));

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

const permissions = getOverrideMetadata(reflector, DECORATOR_KEYS.PERMISSIONS_KEY, context);

import {
    AiPublicModule,
    ExtensionBillingModule,
    ExtensionBillingService,
    PublicAiModelService,
    PublicUserService,
    defineBuildingAITsupConfig,
} from "@buildingai/extension-sdk";

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

    async createArticle(dto: CreateArticleDto, authorId: string) {
        const author = await this.userService.findUserById(authorId);
        if (!author) throw HttpErrorFactory.notFound("作者不存在");
        return this.create({ ...dto, author } as Partial<Article>);
    }
}

@Module({
    imports: [AiPublicModule],
    providers: [MyAiService],
})
export class MyModule {}

@Module({
    imports: [ExtensionBillingModule],
    providers: [ExportService],
})
export class ExportModule {}

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

export default defineBuildingAITsupConfig({
    assets: ["db/seeds/data", "assets/**/*"],
});