323 lines
9.1 KiB
TypeScript
323 lines
9.1 KiB
TypeScript
import { eq, desc, and, like, or, count, sql } from 'drizzle-orm';
|
||
import { app, db, schema } from '../../app.ts';
|
||
import { MarkServices } from './services/mark.ts';
|
||
import z from 'zod';
|
||
|
||
app
|
||
.route({
|
||
path: 'mark',
|
||
key: 'list',
|
||
description: 'mark list.',
|
||
middleware: ['auth'],
|
||
metadata: {
|
||
args: {
|
||
page: z.number().optional().describe('页码'),
|
||
pageSize: z.number().optional().describe('每页数量'),
|
||
search: z.string().optional().describe('搜索关键词'),
|
||
markType: z.string().optional().describe('mark类型,simple,wallnote,md,draw等'),
|
||
sort: z.enum(['DESC', 'ASC']).default('DESC').describe('排序字段'),
|
||
}
|
||
}
|
||
})
|
||
.define(async (ctx) => {
|
||
const tokenUser = ctx.state.tokenUser;
|
||
ctx.body = await MarkServices.getList({
|
||
uid: tokenUser.id,
|
||
query: ctx.query,
|
||
queryType: 'simple',
|
||
});
|
||
})
|
||
.addTo(app);
|
||
|
||
app
|
||
.route({
|
||
path: 'mark',
|
||
key: 'getVersion',
|
||
middleware: ['auth'],
|
||
metadata: {
|
||
args: {
|
||
id: z.string().describe('mark id'),
|
||
}
|
||
},
|
||
})
|
||
.define(async (ctx) => {
|
||
const tokenUser = ctx.state.tokenUser;
|
||
const { id } = ctx.query;
|
||
if (id) {
|
||
const marks = await db.select().from(schema.microMark).where(eq(schema.microMark.id, id)).limit(1);
|
||
const markModel = marks[0];
|
||
if (!markModel) {
|
||
ctx.throw(404, 'mark not found');
|
||
}
|
||
if (markModel.uid !== tokenUser.id) {
|
||
ctx.throw(403, 'no permission');
|
||
}
|
||
ctx.body = {
|
||
version: Number(markModel.version),
|
||
updatedAt: markModel.updatedAt,
|
||
createdAt: markModel.createdAt,
|
||
id: markModel.id,
|
||
};
|
||
} else {
|
||
ctx.throw(400, 'id is required');
|
||
}
|
||
})
|
||
.addTo(app);
|
||
|
||
app
|
||
.route({
|
||
path: 'mark',
|
||
key: 'get',
|
||
middleware: ['auth'],
|
||
metadata: {
|
||
args: {
|
||
|
||
id: z.string().describe('mark id'),
|
||
}
|
||
},
|
||
})
|
||
.define(async (ctx) => {
|
||
const tokenUser = ctx.state.tokenUser;
|
||
const { id } = ctx.query;
|
||
if (id) {
|
||
const marks = await db.select().from(schema.microMark).where(eq(schema.microMark.id, id)).limit(1);
|
||
const markModel = marks[0];
|
||
if (!markModel) {
|
||
ctx.throw(404, 'mark not found');
|
||
}
|
||
if (markModel.uid !== tokenUser.id) {
|
||
ctx.throw(403, 'no permission');
|
||
}
|
||
ctx.body = markModel;
|
||
} else {
|
||
ctx.throw(400, 'id is required');
|
||
}
|
||
})
|
||
.addTo(app);
|
||
|
||
app
|
||
.route({
|
||
path: 'mark',
|
||
key: 'update',
|
||
middleware: ['auth'],
|
||
isDebug: true,
|
||
metadata: {
|
||
args: {
|
||
id: z.string().describe('mark id'),
|
||
}
|
||
},
|
||
})
|
||
.define(async (ctx) => {
|
||
const tokenUser = ctx.state.tokenUser;
|
||
const { id, createdAt, updatedAt, uid: _, puid: _2, uname: _3, data, ...rest } = ctx.query.data || {};
|
||
let markModel: any;
|
||
if (id) {
|
||
const marks = await db.select().from(schema.microMark).where(eq(schema.microMark.id, id)).limit(1);
|
||
markModel = marks[0];
|
||
if (!markModel) {
|
||
ctx.throw(404, 'mark not found');
|
||
}
|
||
if (markModel.uid !== tokenUser.id) {
|
||
ctx.throw(403, 'no permission');
|
||
}
|
||
const version = Number(markModel.version) + 1;
|
||
const updated = await db.update(schema.microMark)
|
||
.set({
|
||
...rest,
|
||
data: {
|
||
...(markModel.data as any || {}),
|
||
...data,
|
||
},
|
||
version,
|
||
updatedAt: new Date().toISOString(),
|
||
})
|
||
.where(eq(schema.microMark.id, id))
|
||
.returning();
|
||
markModel = updated[0];
|
||
} else {
|
||
const inserted = await db.insert(schema.microMark).values({
|
||
data: data || {},
|
||
...rest,
|
||
uname: tokenUser.username,
|
||
uid: tokenUser.id,
|
||
puid: tokenUser.uid,
|
||
}).returning();
|
||
markModel = inserted[0];
|
||
}
|
||
ctx.body = markModel;
|
||
})
|
||
.addTo(app);
|
||
app
|
||
.route({
|
||
path: 'mark',
|
||
key: 'updateNode',
|
||
middleware: ['auth'],
|
||
metadata: {
|
||
args: {
|
||
id: z.string().describe('mark id'),
|
||
operate: z.enum(['update', 'delete']).default('update').describe('节点操作类型，update或delete'),
|
||
data: z.object({
|
||
id: z.string().describe('节点id'),
|
||
node: z.any().describe('要更新的节点数据'),
|
||
}).describe('要更新的节点数据'),
|
||
}
|
||
},
|
||
})
|
||
.define(async (ctx) => {
|
||
const tokenUser = ctx.state.tokenUser;
|
||
const operate = ctx.query.operate || 'update';
|
||
const { id, node } = ctx.query.data || {};
|
||
const marks = await db.select().from(schema.microMark).where(eq(schema.microMark.id, id)).limit(1);
|
||
const markModel = marks[0];
|
||
if (!markModel) {
|
||
ctx.throw(404, 'mark not found');
|
||
}
|
||
if (markModel.uid !== tokenUser.id) {
|
||
ctx.throw(403, 'no permission');
|
||
}
|
||
// Update JSON node logic with Drizzle
|
||
const currentData = markModel.data as any || {};
|
||
const nodes = currentData.nodes || [];
|
||
const nodeIndex = nodes.findIndex((n: any) => n.id === node.id);
|
||
|
||
let updatedNodes;
|
||
if (operate === 'delete') {
|
||
updatedNodes = nodes.filter((n: any) => n.id !== node.id);
|
||
} else if (nodeIndex >= 0) {
|
||
updatedNodes = [...nodes];
|
||
updatedNodes[nodeIndex] = { ...nodes[nodeIndex], ...node };
|
||
} else {
|
||
updatedNodes = [...nodes, node];
|
||
}
|
||
|
||
const version = Number(markModel.version) + 1;
|
||
const updated = await db.update(schema.microMark)
|
||
.set({
|
||
data: { ...currentData, nodes: updatedNodes },
|
||
version,
|
||
updatedAt: new Date().toISOString(),
|
||
})
|
||
.where(eq(schema.microMark.id, id))
|
||
.returning();
|
||
ctx.body = updated[0];
|
||
})
|
||
.addTo(app);
|
||
app
|
||
.route({
|
||
path: 'mark',
|
||
key: 'updateNodes',
|
||
middleware: ['auth'],
|
||
metadata: {
|
||
args: {
|
||
id: z.string().describe('mark id'),
|
||
nodeOperateList: z.array(z.object({
|
||
operate: z.enum(['update', 'delete']).default('update').describe('节点操作类型，update或delete'),
|
||
node: z.any().describe('要更新的节点数据'),
|
||
})).describe('要更新的节点列表'),
|
||
}
|
||
},
|
||
})
|
||
.define(async (ctx) => {
|
||
const tokenUser = ctx.state.tokenUser;
|
||
const { id, nodeOperateList } = ctx.query.data || {};
|
||
const marks = await db.select().from(schema.microMark).where(eq(schema.microMark.id, id)).limit(1);
|
||
const markModel = marks[0];
|
||
if (!markModel) {
|
||
ctx.throw(404, 'mark not found');
|
||
}
|
||
if (markModel.uid !== tokenUser.id) {
|
||
ctx.throw(403, 'no permission');
|
||
}
|
||
if (!nodeOperateList || !Array.isArray(nodeOperateList) || nodeOperateList.length === 0) {
|
||
ctx.throw(400, 'nodeOperateList is required');
|
||
}
|
||
if (nodeOperateList.some((item: any) => !item.node)) {
|
||
ctx.throw(400, 'nodeOperateList node is required');
|
||
}
|
||
|
||
// Update multiple JSON nodes logic with Drizzle
|
||
const currentData = markModel.data as any || {};
|
||
let nodes = currentData.nodes || [];
|
||
|
||
for (const item of nodeOperateList) {
|
||
const { node, operate = 'update' } = item;
|
||
const nodeIndex = nodes.findIndex((n: any) => n.id === node.id);
|
||
|
||
if (operate === 'delete') {
|
||
nodes = nodes.filter((n: any) => n.id !== node.id);
|
||
} else if (nodeIndex >= 0) {
|
||
nodes[nodeIndex] = { ...nodes[nodeIndex], ...node };
|
||
} else {
|
||
nodes.push(node);
|
||
}
|
||
}
|
||
|
||
const version = Number(markModel.version) + 1;
|
||
const updated = await db.update(schema.microMark)
|
||
.set({
|
||
data: { ...currentData, nodes },
|
||
version,
|
||
updatedAt: new Date().toISOString(),
|
||
})
|
||
.where(eq(schema.microMark.id, id))
|
||
.returning();
|
||
ctx.body = updated[0];
|
||
})
|
||
.addTo(app);
|
||
|
||
app
|
||
.route({
|
||
path: 'mark',
|
||
key: 'delete',
|
||
middleware: ['auth'],
|
||
metadata: {
|
||
args: {
|
||
id: z.string().describe('mark id'),
|
||
}
|
||
},
|
||
})
|
||
.define(async (ctx) => {
|
||
const tokenUser = ctx.state.tokenUser;
|
||
const { id } = ctx.query;
|
||
const marks = await db.select().from(schema.microMark).where(eq(schema.microMark.id, id)).limit(1);
|
||
const markModel = marks[0];
|
||
if (!markModel) {
|
||
ctx.throw(404, 'mark not found');
|
||
}
|
||
if (markModel.uid !== tokenUser.id) {
|
||
ctx.throw(403, 'no permission');
|
||
}
|
||
await db.delete(schema.microMark).where(eq(schema.microMark.id, id));
|
||
ctx.body = markModel;
|
||
})
|
||
.addTo(app);
|
||
|
||
app
|
||
.route({
|
||
path: 'mark',
|
||
key: 'getMenu',
|
||
description: '获取菜单',
|
||
middleware: ['auth']
|
||
})
|
||
.define(async (ctx) => {
|
||
const tokenUser = ctx.state.tokenUser;
|
||
const [rows, totalResult] = await Promise.all([
|
||
db.select({
|
||
id: schema.microMark.id,
|
||
title: schema.microMark.title,
|
||
summary: schema.microMark.summary,
|
||
tags: schema.microMark.tags,
|
||
thumbnail: schema.microMark.thumbnail,
|
||
link: schema.microMark.link,
|
||
createdAt: schema.microMark.createdAt,
|
||
updatedAt: schema.microMark.updatedAt,
|
||
}).from(schema.microMark).where(eq(schema.microMark.uid, tokenUser.id)),
|
||
db.select({ count: count() }).from(schema.microMark).where(eq(schema.microMark.uid, tokenUser.id))
|
||
]);
|
||
ctx.body = {
|
||
list: rows,
|
||
total: totalResult[0]?.count || 0,
|
||
};
|
||
})
|
||
.addTo(app);
|