mirror of
https://github.com/certd/certd.git
synced 2026-06-29 07:07:36 +08:00
xiaojunnuo
566 lines
15 KiB
TypeScript
566 lines
15 KiB
TypeScript
import { Inject, Provide, Scope, ScopeEnum } from "@midwayjs/core";
|
|
import { addonRegistry, BaseService, PageReq } from "@certd/lib-server";
|
|
import { PluginEntity } from "../entity/plugin.js";
|
|
import { InjectEntityModel } from "@midwayjs/typeorm";
|
|
import { IsNull, Not, Repository } from "typeorm";
|
|
import { isComm } from "@certd/plus-core";
|
|
import { BuiltInPluginService } from "../../pipeline/service/builtin-plugin-service.js";
|
|
import { merge } from "lodash-es";
|
|
import { accessRegistry, notificationRegistry, pluginRegistry } from "@certd/pipeline";
|
|
import { dnsProviderRegistry } from "@certd/plugin-cert";
|
|
import { logger } from "@certd/basic";
|
|
import yaml from "js-yaml";
|
|
import { getDefaultAccessPlugin, getDefaultDeployPlugin, getDefaultDnsPlugin } from "./default-plugin.js";
|
|
import fs from "fs";
|
|
import path from "path";
|
|
import { RuntimeDepsService } from "../../runtime-deps/runtime-deps-service.js";
|
|
|
|
export type PluginImportReq = {
|
|
content: string;
|
|
override?: boolean;
|
|
};
|
|
|
|
function isBareModuleSpecifier(modulePath: string) {
|
|
if (modulePath.startsWith(".") || modulePath.startsWith("/") || modulePath.startsWith("file:") || modulePath.startsWith("node:")) {
|
|
return false;
|
|
}
|
|
return !/^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(modulePath);
|
|
}
|
|
|
|
async function importLocalModule(modulePath: string) {
|
|
if (!modulePath) {
|
|
throw new Error("modules path 不能为空");
|
|
}
|
|
if (!modulePath.startsWith("/@/")) {
|
|
return await import(modulePath);
|
|
}
|
|
modulePath = modulePath.replace("/@/", "");
|
|
//替换@为相对地址
|
|
modulePath = `../../../${modulePath}`;
|
|
return await import(modulePath);
|
|
}
|
|
|
|
@Provide()
|
|
@Scope(ScopeEnum.Request, { allowDowngrade: true })
|
|
export class PluginService extends BaseService<PluginEntity> {
|
|
@InjectEntityModel(PluginEntity)
|
|
repository: Repository<PluginEntity>;
|
|
|
|
@Inject()
|
|
builtInPluginService: BuiltInPluginService;
|
|
|
|
@Inject()
|
|
runtimeDepsService: RuntimeDepsService;
|
|
|
|
//@ts-ignore
|
|
getRepository() {
|
|
return this.repository;
|
|
}
|
|
|
|
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
|
async page(pageReq: PageReq<PluginEntity>) {
|
|
if (pageReq.query.type && pageReq.query.type !== "builtIn") {
|
|
return await super.page(pageReq);
|
|
}
|
|
//仅查询内置插件
|
|
const offset = pageReq.page.offset;
|
|
const limit = pageReq.page.limit;
|
|
|
|
const builtInList = await this.getBuiltInEntityList();
|
|
|
|
//获取分页数据
|
|
const data = builtInList.slice(offset, offset + limit);
|
|
|
|
return {
|
|
records: data,
|
|
total: builtInList.length,
|
|
offset: offset,
|
|
limit: limit,
|
|
};
|
|
}
|
|
|
|
async getEnabledBuildInGroup(opts?: { isSimple?: boolean; withSetting?: boolean }) {
|
|
const groups = this.builtInPluginService.getGroups();
|
|
if (opts?.isSimple) {
|
|
for (const key in groups) {
|
|
const group = groups[key];
|
|
group.plugins.forEach(item => {
|
|
delete item.input;
|
|
});
|
|
}
|
|
}
|
|
|
|
if (!isComm()) {
|
|
return groups;
|
|
}
|
|
|
|
// 初始化设置
|
|
const settingPlugins = await this.repository.find({
|
|
select: {
|
|
id: true,
|
|
name: true,
|
|
sysSetting: true,
|
|
},
|
|
where: {
|
|
sysSetting: Not(IsNull()),
|
|
},
|
|
});
|
|
//合并插件配置
|
|
const pluginSettingMap: any = {};
|
|
for (const item of settingPlugins) {
|
|
if (!item.sysSetting) {
|
|
continue;
|
|
}
|
|
pluginSettingMap[item.name] = JSON.parse(item.sysSetting);
|
|
}
|
|
for (const key in groups) {
|
|
const group = groups[key];
|
|
if (!group.plugins) {
|
|
continue;
|
|
}
|
|
for (const item of group.plugins) {
|
|
const pluginSetting = pluginSettingMap[item.name];
|
|
if (pluginSetting) {
|
|
item.sysSetting = pluginSetting;
|
|
}
|
|
}
|
|
}
|
|
|
|
//排除禁用的
|
|
const list = await this.list({
|
|
query: {
|
|
disabled: true,
|
|
},
|
|
});
|
|
const disabledNames = list.map(it => it.name);
|
|
for (const key in groups) {
|
|
const group = groups[key];
|
|
if (!group.plugins) {
|
|
continue;
|
|
}
|
|
group.plugins = group.plugins.filter(it => !disabledNames.includes(it.name));
|
|
}
|
|
return groups;
|
|
}
|
|
|
|
async getEnabledBuiltInList(): Promise<any> {
|
|
const builtInList = this.builtInPluginService.getList();
|
|
if (!isComm()) {
|
|
return builtInList;
|
|
}
|
|
|
|
const list = await this.list({
|
|
query: {
|
|
type: "builtIn",
|
|
disabled: true,
|
|
},
|
|
});
|
|
const disabledNames = list.map(it => it.name);
|
|
|
|
return builtInList.filter(it => {
|
|
return !disabledNames.includes(it.name);
|
|
});
|
|
}
|
|
|
|
async getBuiltInEntityList() {
|
|
const builtInList = this.builtInPluginService.getList();
|
|
const list = await this.list({
|
|
query: {
|
|
type: "builtIn",
|
|
},
|
|
});
|
|
|
|
const records: PluginEntity[] = [];
|
|
|
|
for (const item of builtInList) {
|
|
let record = list.find(it => it.name === item.name);
|
|
if (!record) {
|
|
record = new PluginEntity();
|
|
record.disabled = false;
|
|
}
|
|
merge(record, {
|
|
name: item.name,
|
|
title: item.title,
|
|
type: "builtIn",
|
|
icon: item.icon,
|
|
desc: item.desc,
|
|
group: item.group,
|
|
});
|
|
records.push(record);
|
|
}
|
|
return records;
|
|
}
|
|
|
|
async setDisabled(opts: { id?: number; name?: string; type: string; disabled: boolean }) {
|
|
const { id, name, type, disabled } = opts;
|
|
if (!type) {
|
|
throw new Error("参数错误: type 不能为空");
|
|
}
|
|
if (id > 0) {
|
|
//update
|
|
await this.repository.update({ id }, { disabled });
|
|
return;
|
|
}
|
|
|
|
if (name && type === "builtIn") {
|
|
const pluginEntity = new PluginEntity();
|
|
pluginEntity.name = name;
|
|
pluginEntity.type = type;
|
|
pluginEntity.disabled = disabled;
|
|
await this.repository.save(pluginEntity);
|
|
return;
|
|
}
|
|
throw new Error("参数错误: id 和 name 必须有一个");
|
|
}
|
|
|
|
async getDefineByType(type: string) {
|
|
return this.builtInPluginService.getByType(type);
|
|
}
|
|
|
|
/**
|
|
* 新增
|
|
* @param param 数据
|
|
*/
|
|
async add(param: any) {
|
|
const old = await this.repository.findOne({
|
|
where: {
|
|
name: param.name,
|
|
author: param.author,
|
|
},
|
|
});
|
|
|
|
if (old) {
|
|
throw new Error(`插件${param.author}/${param.name}已存在`);
|
|
}
|
|
|
|
if (param.type === "builtIn") {
|
|
return await super.add({
|
|
...param,
|
|
});
|
|
}
|
|
|
|
let plugin: any = {};
|
|
if (param.pluginType === "access") {
|
|
plugin = getDefaultAccessPlugin();
|
|
delete param.group;
|
|
} else if (param.pluginType === "deploy") {
|
|
plugin = getDefaultDeployPlugin();
|
|
} else if (param.pluginType === "dnsProvider") {
|
|
plugin = getDefaultDnsPlugin();
|
|
delete param.group;
|
|
} else {
|
|
throw new Error(`插件类型${param.pluginType}不支持`);
|
|
}
|
|
|
|
const res = await super.add({
|
|
...param,
|
|
...plugin,
|
|
});
|
|
|
|
await this.registerById(res.id);
|
|
return res;
|
|
}
|
|
|
|
async registerById(id: any) {
|
|
const item = await this.info(id);
|
|
if (!item) {
|
|
return;
|
|
}
|
|
if (item.type === "builtIn") {
|
|
return;
|
|
}
|
|
await this.registerPlugin(item);
|
|
}
|
|
|
|
async unRegisterById(id: any) {
|
|
const item = await this.info(id);
|
|
if (!item) {
|
|
return;
|
|
}
|
|
if (item.type === "builtIn") {
|
|
return;
|
|
}
|
|
let name = item.name;
|
|
if (item.author && !item.name.startsWith(`${item.author}/`)) {
|
|
name = `${item.author}/${item.name}`;
|
|
}
|
|
if (item.pluginType === "access") {
|
|
accessRegistry.unRegister(name);
|
|
} else if (item.pluginType === "deploy") {
|
|
pluginRegistry.unRegister(name);
|
|
} else if (item.pluginType === "dnsProvider") {
|
|
dnsProviderRegistry.unRegister(name);
|
|
} else if (item.pluginType === "notification") {
|
|
notificationRegistry.unRegister(name);
|
|
} else if (item.pluginType === "addon") {
|
|
addonRegistry.unRegister(name);
|
|
} else {
|
|
logger.warn(`不支持的插件类型：${item.pluginType}`);
|
|
}
|
|
}
|
|
|
|
async update(param: any) {
|
|
const old = await this.repository.findOne({
|
|
where: {
|
|
name: param.name,
|
|
author: param.author,
|
|
},
|
|
});
|
|
|
|
if (old && old.id !== param.id) {
|
|
throw new Error(`插件${param.author}/${param.name}已存在`);
|
|
}
|
|
|
|
await this.unRegisterById(param.id);
|
|
const res = await super.update(param);
|
|
|
|
await this.registerById(param.id);
|
|
return res;
|
|
}
|
|
|
|
async compile(code: string) {
|
|
const ts = await import("typescript");
|
|
return ts.transpileModule(code, {
|
|
compilerOptions: { module: ts.ModuleKind.ESNext },
|
|
}).outputText;
|
|
}
|
|
|
|
async importer(modulePath: string) {
|
|
if (!modulePath) {
|
|
throw new Error("modules path 不能为空");
|
|
}
|
|
if (!isBareModuleSpecifier(modulePath)) {
|
|
return await importLocalModule(modulePath);
|
|
}
|
|
return await this.runtimeDepsService.importRuntime(modulePath, logger);
|
|
}
|
|
|
|
private async getPluginClassFromFile(item: any) {
|
|
const scriptFilePath = item.scriptFilePath;
|
|
const res = await import(`../../..${scriptFilePath}`);
|
|
const classNames = Object.keys(res);
|
|
return res[classNames[classNames.length - 1]];
|
|
}
|
|
|
|
async getPluginClassFromDb(pluginName: string) {
|
|
//获取插件类实例对象
|
|
let author = undefined;
|
|
let name = "";
|
|
if (pluginName.includes("/")) {
|
|
const arr = pluginName.split("/");
|
|
author = arr[0];
|
|
name = arr[1];
|
|
} else {
|
|
name = pluginName;
|
|
}
|
|
const info = await this.find({
|
|
where: {
|
|
name: name,
|
|
author: author,
|
|
},
|
|
});
|
|
if (info && info.length > 0) {
|
|
const plugin = info[0];
|
|
try {
|
|
const AsyncFunction = Object.getPrototypeOf(async () => {}).constructor;
|
|
// const script = await this.compile(plugin.content);
|
|
const script = plugin.content;
|
|
const getPluginClass = new AsyncFunction("_ctx", script);
|
|
const importer = this.importer.bind(this);
|
|
return await getPluginClass({ logger: logger, import: importer });
|
|
} catch (e) {
|
|
logger.error("编译插件失败:", e);
|
|
throw e;
|
|
}
|
|
}
|
|
throw new Error(`插件${pluginName}不存在`);
|
|
}
|
|
|
|
/**
|
|
* 从数据库加载插件
|
|
*/
|
|
async registerFromDb() {
|
|
const res = await this.list({
|
|
buildQuery: bq => {
|
|
bq.andWhere("type != :type", {
|
|
type: "builtIn",
|
|
});
|
|
},
|
|
});
|
|
|
|
for (const item of res) {
|
|
await this.registerPlugin(item);
|
|
}
|
|
}
|
|
|
|
async registerFromLocal(localDir: string) {
|
|
//scan path
|
|
const files = fs.readdirSync(localDir);
|
|
let list = [];
|
|
for (const file of files) {
|
|
if (!file.endsWith(".yaml")) {
|
|
continue;
|
|
}
|
|
const item = yaml.load(fs.readFileSync(path.join(localDir, file), "utf8"));
|
|
|
|
list.push(item);
|
|
}
|
|
//排序
|
|
list = list.sort((a, b) => {
|
|
return (a.order ?? 10) - (b.order ?? 10);
|
|
});
|
|
|
|
for (const item of list) {
|
|
await this.registerPlugin(item);
|
|
}
|
|
}
|
|
|
|
async registerPlugin(plugin: PluginEntity) {
|
|
const metadata = plugin.metadata ? yaml.load(plugin.metadata) : {};
|
|
const extra = plugin.extra ? yaml.load(plugin.extra) : {};
|
|
const item = {
|
|
...plugin,
|
|
...metadata,
|
|
...extra,
|
|
};
|
|
delete item.metadata;
|
|
delete item.content;
|
|
delete item.extra;
|
|
if (item.author && !item.name.startsWith(`${item.author}/`)) {
|
|
item.name = item.author + "/" + item.name;
|
|
}
|
|
let name = item.name;
|
|
if (item.addonType) {
|
|
name = item.addonType + ":" + name;
|
|
}
|
|
let registry = null;
|
|
if (item.pluginType === "access") {
|
|
registry = accessRegistry;
|
|
} else if (item.pluginType === "deploy") {
|
|
registry = pluginRegistry;
|
|
} else if (item.pluginType === "dnsProvider") {
|
|
registry = dnsProviderRegistry;
|
|
} else if (item.pluginType === "notification") {
|
|
registry = notificationRegistry;
|
|
} else if (item.pluginType === "addon") {
|
|
registry = addonRegistry;
|
|
} else {
|
|
logger.warn(`插件${name}类型错误:${item.pluginType}`);
|
|
return;
|
|
}
|
|
|
|
registry.register(name, {
|
|
define: item,
|
|
target: async () => {
|
|
if (item.type === "builtIn") {
|
|
return await this.getPluginClassFromFile(item);
|
|
} else {
|
|
return await this.getPluginClassFromDb(name);
|
|
}
|
|
},
|
|
});
|
|
}
|
|
|
|
async getRuntimeDependencyPluginDefines() {
|
|
const builtInList = await this.getEnabledBuiltInList();
|
|
const customList = await this.list({
|
|
buildQuery: bq => {
|
|
bq.andWhere("type != :type", {
|
|
type: "builtIn",
|
|
});
|
|
},
|
|
});
|
|
const list = [...builtInList];
|
|
for (const plugin of customList) {
|
|
const metadata = plugin.metadata ? yaml.load(plugin.metadata) : {};
|
|
const extra = plugin.extra ? yaml.load(plugin.extra) : {};
|
|
list.push({ ...plugin, ...metadata, ...extra });
|
|
}
|
|
return list.filter(item => item.dependPackages);
|
|
}
|
|
|
|
async exportPlugin(id: number) {
|
|
const info = await this.info(id);
|
|
if (!info) {
|
|
throw new Error("插件不存在");
|
|
}
|
|
const metadata = yaml.load(info.metadata || "");
|
|
const extra = yaml.load(info.extra || "");
|
|
const content = info.content;
|
|
delete info.metadata;
|
|
delete info.extra;
|
|
delete info.content;
|
|
delete info.id;
|
|
delete info.createTime;
|
|
delete info.updateTime;
|
|
const plugin = {
|
|
...info,
|
|
...metadata,
|
|
...extra,
|
|
content,
|
|
};
|
|
|
|
return yaml.dump(plugin) as string;
|
|
}
|
|
|
|
async importPlugin(req: PluginImportReq) {
|
|
const loaded = yaml.load(req.content);
|
|
if (!loaded) {
|
|
throw new Error("插件内容不能为空");
|
|
}
|
|
delete loaded.id;
|
|
|
|
const old = await this.repository.findOne({
|
|
where: {
|
|
name: loaded.name,
|
|
author: loaded.author,
|
|
},
|
|
});
|
|
|
|
const metadata = {
|
|
input: loaded.input,
|
|
output: loaded.output,
|
|
};
|
|
const extra = {
|
|
dependPlugins: loaded.dependPlugins,
|
|
dependPackages: loaded.dependPackages,
|
|
default: loaded.default,
|
|
showRunStrategy: loaded.showRunStrategy,
|
|
};
|
|
|
|
const pluginEntity = {
|
|
...loaded,
|
|
metadata: yaml.dump(metadata),
|
|
extra: yaml.dump(extra),
|
|
content: loaded.content,
|
|
disabled: false,
|
|
};
|
|
if (!pluginEntity.pluginType) {
|
|
throw new Error(`插件类型不能为空`);
|
|
}
|
|
|
|
if (!old) {
|
|
//add
|
|
const { id } = await this.add(pluginEntity);
|
|
pluginEntity.id = id;
|
|
} else {
|
|
if (!req.override) {
|
|
throw new Error(`插件${loaded.author}/${loaded.name}已存在`);
|
|
}
|
|
pluginEntity.id = old.id;
|
|
}
|
|
//update
|
|
await this.update(pluginEntity);
|
|
return {
|
|
id: pluginEntity.id,
|
|
};
|
|
}
|
|
async deleteByIds(ids: any[]) {
|
|
ids = this.filterIds(ids);
|
|
for (const id of ids) {
|
|
await this.unRegisterById(id);
|
|
await this.delete(id);
|
|
}
|
|
}
|
|
}
|