后端工具与封装开发文档

import { BaseController } from "@chatbuddy-ai/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 "@chatbuddy-ai/base";
import { InjectRepository } from "@chatbuddy-ai/db/@nestjs/typeorm";
import { Repository } from "@chatbuddy-ai/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 "@chatbuddy-ai/db/typeorm";
import { buildWhere } from "@chatbuddy-ai/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 "@chatbuddy-ai/base/services/base.service"; await this.updateById(id, dto, { lock: { type: LockType.PESSIMISTIC_WRITE, retryCount: 3, retryDelay: 100, },
});

import { PaginationDto } from "@chatbuddy-ai/dto";
import { IsOptional, IsString } from "class-validator"; export class QueryArticleDto extends PaginationDto { @IsOptional @IsString title?: string;
}

import { UUIDValidationPipe } from "@chatbuddy-ai/pipe/param-validate.pipe"; @Get(":id")
findOne(@Param("id", UUIDValidationPipe) id: string) { return this.service.findOneById(id);
}

import { HttpErrorFactory } from "@chatbuddy-ai/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 "@chatbuddy-ai/decorators"; @Public
@Get("config")
getPublicConfig {}

import { Playground } from "@chatbuddy-ai/decorators/playground.decorator";
import type { UserPlayground } from "@chatbuddy-ai/db"; @Post
create(@Body dto: CreateDto, @Playground user: UserPlayground) { return this.service.create(dto, user.id);
}

import { BuildFileUrl } from "@chatbuddy-ai/decorators"; @BuildFileUrl(["avatar", "cover", "author.avatar", "items.*.thumbnail"])
@Get
list {}

import { SkipTransform } from "@chatbuddy-ai/decorators"; @SkipTransform
@Post("webhook")
webhook { return "success";
}

import { SuperAdminOnly } from "@chatbuddy-ai/decorators"; @SuperAdminOnly
@Delete(":id")
removeSystemResource {}

import { ExtensionWebController } from "@chatbuddy-ai/core/decorators"; @ExtensionWebController("article")
export class ArticleWebController { @Get list {}
}

/{extensionIdentifier}/api/{path}

import { ExtensionConsoleController } from "@chatbuddy-ai/core/decorators"; @ExtensionConsoleController("article", "文章管理")
export class ArticleController extends BaseController {}

/{extensionIdentifier}/console/{path}

{extensionIdentifier}@{path}

import { ExtensionEntity } from "@chatbuddy-ai/core/decorators";
import { Column, PrimaryGeneratedColumn } from "@chatbuddy-ai/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 "@chatbuddy-ai/db/@nestjs/typeorm";
import { User } from "@chatbuddy-ai/db/entities";
import { DataSource, Repository } from "@chatbuddy-ai/db/typeorm";

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

import { BaseSeeder } from "@chatbuddy-ai/db"; export class ArticleSeeder extends BaseSeeder { async run { // seed data }
}

import { UploadModule, FileUploadService } from "@chatbuddy-ai/core/modules"; @Module({ imports: [UploadModule], providers: [MyService],
})
export class MyModule {}

import { CloudStorageModule, CloudStorageService } from "@chatbuddy-ai/core/modules";

import { QueueModule, QueueService } from "@chatbuddy-ai/core/modules"; @Module({ imports: [QueueModule],
})
export class WorkerModule { constructor(private readonly queueService: QueueService) {}
}

import { AppBillingService, BillingModule } from "@chatbuddy-ai/core/modules";

import { SecretModule, SecretService } from "@chatbuddy-ai/core/modules";

import { ExtensionsService } from "@chatbuddy-ai/core/modules";

import { ScheduleService } from "@chatbuddy-ai/core";

import { CacheModule, CacheService, RedisModule, RedisService } from "@chatbuddy-ai/cache";

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

import { asArray, asBoolean, asDate, asDefined, asError, asJson, asNumber, asObject, asOneOf, asString,
} from "@chatbuddy-ai/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 "@chatbuddy-ai/utils";
import { Like } from "@chatbuddy-ai/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 "@chatbuddy-ai/utils"; validatePath(pathSegment);
const route = joinRouterPaths("simple-blog", "console", "article");
const filePath = joinPaths(root, "storage", "uploads");

import { isDevelopment, isDisabled, isEnabled, isProduction } from "@chatbuddy-ai/utils"; if (isEnabled(user.status)) {
}
if (isDisabled(config.status)) {
}
isDevelopment( => this.logger.debug("debug only"));

import { getOverrideMetadata } from "@chatbuddy-ai/utils"; const permissions = getOverrideMetadata(reflector, DECORATOR_KEYS.PERMISSIONS_KEY, context);

import { AiPublicModule, ExtensionBillingModule, ExtensionBillingService, PublicAiModelService, PublicUserService, defineChatbuddy AITsupConfig,
} from "@chatbuddy-ai/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 { defineChatbuddy AITsupConfig } from "@chatbuddy-ai/extension-sdk"; export default defineChatbuddy AITsupConfig({ assets: ["db/seeds/data", "assets/**/*"],
});