@wordrhyme/auto-crud-server 0.2.0 → 0.4.0

package/README.md

@@ -136,7 +136,7 @@ export { handler as GET, handler as POST };
 
 ## 📖 自动生成的路由
 
-`createCrudRouter` 会自动生成以下 6 个路由：
+`createCrudRouter` 会自动生成以下 7 个路由：
 
 ### 1. `list` - 列表查询
 
@@ -276,6 +276,29 @@ void
 await trpc.tasks.deleteMany({ ids: ["1", "2", "3"] });
 ```
 
+### 7. `updateMany` - 批量更新
+
+**输入**:
+```typescript
+{
+  ids: string[];
+  data: Partial<Omit<Task, "id" | "createdAt" | "updatedAt">>;
+}
+```
+
+**输出**:
+```typescript
+{ updated: number }
+```
+
+**示例**:
+```typescript
+await trpc.tasks.updateMany({
+  ids: ["1", "2", "3"],
+  data: { status: "done" },
+});
+```
+
 ---
 
 ## 🎯 高级过滤
@@ -392,13 +415,21 @@ interface CrudRouterConfig<TTable, TSelect, TInsert, TUpdate> {
 #### 返回值
 
 ```typescript
+// 返回增强的 tRPC router，带有 .procedures 属性
 {
-  list: Procedure<ListInput, ListOutput>,
-  get: Procedure<{ id: string }, TSelect>,
-  create: Procedure<TInsert, TSelect>,
-  update: Procedure<{ id: string, data: TUpdate }, TSelect>,
-  delete: Procedure<{ id: string }, void>,
-  deleteMany: Procedure<{ ids: string[] }, void>,
+  // 标准 tRPC router（可直接嵌套到 appRouter）
+  ...routerMethods,
+
+  // 可 spread 的 procedures 对象（用于扩展自定义路由）
+  procedures: {
+    list: Procedure<ListInput, ListOutput>,
+    getById: Procedure<string, TSelect>,
+    create: Procedure<TInsert, TSelect>,
+    update: Procedure<{ id: string, data: TUpdate }, TSelect>,
+    delete: Procedure<string, TSelect>,
+    deleteMany: Procedure<string[], { deleted: number }>,
+    updateMany: Procedure<{ ids: string[], data: TUpdate }, { updated: number }>,
+  }
 }
 ```
 
@@ -487,24 +518,29 @@ const result = await db
 
 ## 🎨 自定义扩展
 
-### 添加自定义路由
+### 添加自定义路由（推荐方式）
+
+使用 `.procedures` 属性 spread 出 CRUD 路由，然后添加自定义路由：
 
 ```typescript
-import { createCrudRouter } from "@wordrhyme/auto-crud-server";
-import { publicProcedure } from "../trpc";
+import { createCrudRouter, router } from "@wordrhyme/auto-crud-server";
+import { protectedProcedure } from "../trpc";
+import { z } from "zod";
 
-const baseCrudRouter = createCrudRouter({
+// 创建基础 CRUD
+const tasksCrud = createCrudRouter({
   table: tasks,
   selectSchema: selectTaskSchema,
   insertSchema: insertTaskSchema,
   updateSchema: updateTaskSchema,
 });
 
-export const tasksRouter = {
-  ...baseCrudRouter,
+// 使用 .procedures spread 并添加自定义路由
+export const tasksRouter = router({
+  ...tasksCrud.procedures,
 
-  // 添加自定义路由
-  archive: publicProcedure
+  // 自定义路由：归档
+  archive: protectedProcedure
     .input(z.object({ id: z.string() }))
     .mutation(async ({ input, ctx }) => {
       return ctx.db
@@ -513,7 +549,8 @@ export const tasksRouter = {
         .where(eq(tasks.id, input.id));
     }),
 
-  unarchive: publicProcedure
+  // 自定义路由：取消归档
+  unarchive: protectedProcedure
     .input(z.object({ id: z.string() }))
     .mutation(async ({ input, ctx }) => {
       return ctx.db
@@ -521,30 +558,52 @@ export const tasksRouter = {
         .set({ archived: false })
         .where(eq(tasks.id, input.id));
     }),
-};
+});
+```
+
+### 直接使用（不需要扩展时）
+
+如果不需要添加自定义路由，可以直接使用返回的 router：
+
+```typescript
+const tasksCrud = createCrudRouter({
+  table: tasks,
+  selectSchema: selectTaskSchema,
+  insertSchema: insertTaskSchema,
+  updateSchema: updateTaskSchema,
+});
+
+// 直接嵌套到 appRouter
+export const appRouter = router({
+  tasks: tasksCrud,
+});
 ```
 
 ### 自定义过滤逻辑
 
 ```typescript
-// 在 createCrudRouter 之前预处理过滤条件
-const customList = publicProcedure
-  .input(listInputSchema)
-  .query(async ({ input, ctx }) => {
-    // 自定义过滤逻辑
-    const customFilters = input.filters?.map(filter => {
-      if (filter.id === "customField") {
-        // 自定义处理
-        return { ...filter, operator: "custom" };
-      }
-      return filter;
-    });
-
-    return baseCrudRouter.list({
-      ...input,
-      filters: customFilters,
-    }, ctx);
-  });
+// 覆盖 list 路由，添加自定义过滤逻辑
+const tasksCrud = createCrudRouter({ ... });
+
+export const tasksRouter = router({
+  ...tasksCrud.procedures,
+
+  // 覆盖 list，添加自定义逻辑
+  list: protectedProcedure
+    .input(listInputSchema)
+    .query(async ({ input, ctx }) => {
+      // 自定义过滤逻辑
+      const customFilters = input.filters?.map(filter => {
+        if (filter.id === "customField") {
+          return { ...filter, operator: "custom" };
+        }
+        return filter;
+      });
+
+      // 调用原始 list（需要手动实现或使用 db 查询）
+      return ctx.db.select().from(tasks).where(...);
+    }),
+});
 ```
 
 ---

package/dist/index.cjs

@@ -401,9 +401,58 @@ const dataTableConfig = {
 
 //#endregion
 //#region src/routers/_factory.ts
-/**
-* 过滤器项 Schema
-*/
+function resolveSoftDelete(option) {
+	if (!option) return null;
+	if (option === true) return {
+		column: "deletedAt",
+		getValue: () => /* @__PURE__ */ new Date()
+	};
+	if (typeof option === "string") return {
+		column: option,
+		getValue: () => /* @__PURE__ */ new Date()
+	};
+	const config = option;
+	return {
+		column: config.column,
+		getValue: config.value ?? (() => /* @__PURE__ */ new Date())
+	};
+}
+function resolveConfig(config) {
+	const mode = config.mode || "declarative";
+	if (mode === "factory") {
+		const factoryConfig = config;
+		return {
+			procedureFactory: factoryConfig.procedureFactory,
+			guard: void 0,
+			getScope: () => void 0,
+			getInject: (ctx, op) => factoryConfig.inject?.(ctx, op) ?? {},
+			checkAuthorize: async () => true
+		};
+	}
+	if (mode === "procedures") {
+		const proceduresConfig = config;
+		const defaultProc = proceduresConfig.defaultProcedure ?? publicProcedure;
+		return {
+			procedureFactory: (op) => proceduresConfig.procedures[op] ?? defaultProc,
+			guard: void 0,
+			getScope: () => void 0,
+			getInject: (ctx, op) => proceduresConfig.inject?.(ctx, op) ?? {},
+			checkAuthorize: async () => true
+		};
+	}
+	const declarativeConfig = config;
+	const baseProcedure = declarativeConfig.procedure ?? publicProcedure;
+	return {
+		procedureFactory: () => baseProcedure,
+		guard: declarativeConfig.guard,
+		getScope: (ctx, tbl, op) => declarativeConfig.scope?.(ctx, tbl, op),
+		getInject: (ctx, op) => declarativeConfig.inject?.(ctx, op) ?? {},
+		checkAuthorize: async (ctx, resource, op) => {
+			if (declarativeConfig.authorize) return declarativeConfig.authorize(ctx, resource, op);
+			return true;
+		}
+	};
+}
 const filterItemSchema = zod.z.object({
 	id: zod.z.string(),
 	value: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]),
@@ -411,9 +460,6 @@ const filterItemSchema = zod.z.object({
 	operator: zod.z.enum(dataTableConfig.operators),
 	filterId: zod.z.string()
 });
-/**
-* 列表查询输入 Schema
-*/
 const listInputSchema = zod.z.object({
 	page: zod.z.number().min(1).default(1),
 	perPage: zod.z.number().min(1).max(100).default(10),
@@ -424,98 +470,178 @@ const listInputSchema = zod.z.object({
 	filters: zod.z.array(filterItemSchema).optional(),
 	joinOperator: zod.z.enum(["and", "or"]).default("and")
 });
-/**
-* 验证列是否在白名单中
-*/
-function validateColumn(columnId, allowedColumns, columnType) {
+function validateColumn(columnId, allowedColumns) {
 	if (!allowedColumns || allowedColumns.length === 0) return true;
 	return allowedColumns.includes(columnId);
 }
-/**
-* 创建通用 CRUD Router
-*/
 function createCrudRouter(config) {
-	const { table, insertSchema, updateSchema, idField = "id", filterableColumns, sortableColumns, maxBatchSize = 100, procedure: baseProcedure = publicProcedure, authorize } = config;
+	const { table, insertSchema, updateSchema, idField = "id", filterableColumns, sortableColumns, maxBatchSize = 100, softDelete: softDeleteOption, hooks = {} } = config;
+	const resolved = resolveConfig(config);
+	const softDelete = resolveSoftDelete(softDeleteOption);
+	const h = hooks;
 	const getIdColumn = () => table[idField];
-	const withAuthorize = async (operation, input) => {
-		if (authorize) {
-			if (!await authorize({
-				operation,
-				input
-			})) throw new Error(`Unauthorized: ${operation} operation not allowed`);
+	const getSoftDeleteColumn = () => softDelete ? table[softDelete.column] : null;
+	const buildWhere = (ctx, operation, additionalCondition) => {
+		const conditions = [];
+		const scopeCondition = resolved.getScope(ctx, table, operation);
+		if (scopeCondition) conditions.push(scopeCondition);
+		if (softDelete && (operation === "list" || operation === "get")) {
+			const col = getSoftDeleteColumn();
+			if (col) conditions.push((0, drizzle_orm.isNull)(col));
+		}
+		if (additionalCondition) conditions.push(additionalCondition);
+		if (conditions.length === 0) return void 0;
+		if (conditions.length === 1) return conditions[0];
+		return (0, drizzle_orm.and)(...conditions);
+	};
+	const withGuard = async (ctx, operation) => {
+		if (resolved.guard) {
+			if (!await resolved.guard(ctx, operation)) throw new Error(`Forbidden: ${operation} not allowed`);
 		}
 	};
-	return router({
-		list: baseProcedure.input(listInputSchema).query(async ({ ctx, input }) => {
-			await withAuthorize("list", input);
-			const offset = (input.page - 1) * input.perPage;
-			const validatedFilters = input.filters?.filter((filter) => validateColumn(filter.id, filterableColumns, "filter"));
-			const where = validatedFilters?.length ? filterColumns({
+	const withAuthorize = async (ctx, resource, operation) => {
+		if (!resource) return;
+		if (!await resolved.checkAuthorize(ctx, resource, operation)) throw new Error(`Forbidden: Cannot ${operation} this resource`);
+	};
+	const procedures = {
+		list: resolved.procedureFactory("list").input(listInputSchema).query(async ({ ctx, input }) => {
+			await withGuard(ctx, "list");
+			let processedInput = input;
+			if (h.beforeList) {
+				const result = await h.beforeList(ctx, processedInput);
+				if (result) processedInput = result;
+			}
+			const offset = (processedInput.page - 1) * processedInput.perPage;
+			const validatedFilters = processedInput.filters?.filter((filter) => validateColumn(filter.id, filterableColumns));
+			const where = buildWhere(ctx, "list", validatedFilters?.length ? filterColumns({
 				table,
 				filters: validatedFilters,
-				joinOperator: input.joinOperator
-			}) : void 0;
+				joinOperator: processedInput.joinOperator
+			}) : void 0);
 			let query = ctx.db.select().from(table).$dynamic();
 			if (where) query = query.where(where);
-			if (input.sort?.length) {
-				const sortField = input.sort[0];
-				if (sortField && validateColumn(sortField.id, sortableColumns, "sort")) {
+			if (processedInput.sort?.length) {
+				const sortField = processedInput.sort[0];
+				if (sortField && validateColumn(sortField.id, sortableColumns)) {
 					const column = table[sortField.id];
 					if (column) query = query.orderBy(sortField.desc ? (0, drizzle_orm.desc)(column) : (0, drizzle_orm.asc)(column));
 				}
 			}
-			const data = await query.limit(input.perPage).offset(offset);
+			const data = await query.limit(processedInput.perPage).offset(offset);
 			let countQuery = ctx.db.select({ count: drizzle_orm.sql`count(*)::int` }).from(table).$dynamic();
 			if (where) countQuery = countQuery.where(where);
 			const count = (await countQuery)[0]?.count ?? 0;
-			return {
+			let listResult = {
 				data,
 				total: count,
-				page: input.page,
-				perPage: input.perPage,
-				pageCount: Math.ceil(count / input.perPage)
+				page: processedInput.page,
+				perPage: processedInput.perPage,
+				pageCount: Math.ceil(count / processedInput.perPage)
 			};
+			if (h.afterList) {
+				const result = await h.afterList(ctx, listResult);
+				if (result) listResult = result;
+			}
+			return listResult;
 		}),
-		getById: baseProcedure.input(zod.z.string()).query(async ({ ctx, input }) => {
-			await withAuthorize("get", input);
-			const column = getIdColumn();
-			const [item] = await ctx.db.select().from(table).where((0, drizzle_orm.eq)(column, input));
-			return item ?? null;
+		getById: resolved.procedureFactory("get").input(zod.z.string()).query(async ({ ctx, input }) => {
+			await withGuard(ctx, "get");
+			if (h.beforeGet) await h.beforeGet(ctx, input);
+			const where = buildWhere(ctx, "get", (0, drizzle_orm.eq)(getIdColumn(), input));
+			const [item] = await ctx.db.select().from(table).where(where);
+			await withAuthorize(ctx, item, "get");
+			let result = item ?? null;
+			if (h.afterGet) {
+				const hookResult = await h.afterGet(ctx, result);
+				if (hookResult !== void 0) result = hookResult;
+			}
+			return result;
 		}),
-		create: baseProcedure.input(insertSchema).mutation(async ({ ctx, input }) => {
-			await withAuthorize("create", input);
-			const [created] = await ctx.db.insert(table).values(input).returning();
+		create: resolved.procedureFactory("create").input(insertSchema).mutation(async ({ ctx, input }) => {
+			await withGuard(ctx, "create");
+			let processedData = input;
+			if (h.beforeCreate) {
+				const result = await h.beforeCreate(ctx, processedData);
+				if (result) processedData = result;
+			}
+			const injectData = resolved.getInject(ctx, "create");
+			const data = {
+				...processedData,
+				...injectData
+			};
+			const [created] = await ctx.db.insert(table).values(data).returning();
+			if (h.afterCreate) await h.afterCreate(ctx, created);
 			return created;
 		}),
-		update: baseProcedure.input(zod.z.object({
+		update: resolved.procedureFactory("update").input(zod.z.object({
 			id: zod.z.string(),
 			data: updateSchema
 		})).mutation(async ({ ctx, input }) => {
-			await withAuthorize("update", input);
-			const column = getIdColumn();
-			const [updated] = await ctx.db.update(table).set(input.data).where((0, drizzle_orm.eq)(column, input.id)).returning();
+			await withGuard(ctx, "update");
+			const where = buildWhere(ctx, "update", (0, drizzle_orm.eq)(getIdColumn(), input.id));
+			const [existing] = await ctx.db.select().from(table).where(where);
+			await withAuthorize(ctx, existing, "update");
+			if (!existing) throw new Error("Resource not found or access denied");
+			let processedData = input.data;
+			if (h.beforeUpdate) {
+				const result = await h.beforeUpdate(ctx, input.id, processedData, existing);
+				if (result) processedData = result;
+			}
+			const injectData = resolved.getInject(ctx, "update");
+			const data = {
+				...processedData,
+				...injectData
+			};
+			const [updated] = await ctx.db.update(table).set(data).where(where).returning();
+			if (h.afterUpdate) await h.afterUpdate(ctx, updated);
 			return updated;
 		}),
-		delete: baseProcedure.input(zod.z.string()).mutation(async ({ ctx, input }) => {
-			await withAuthorize("delete", input);
-			const column = getIdColumn();
-			const [deleted] = await ctx.db.delete(table).where((0, drizzle_orm.eq)(column, input)).returning();
+		delete: resolved.procedureFactory("delete").input(zod.z.string()).mutation(async ({ ctx, input }) => {
+			await withGuard(ctx, "delete");
+			const where = buildWhere(ctx, "delete", (0, drizzle_orm.eq)(getIdColumn(), input));
+			const [existing] = await ctx.db.select().from(table).where(where);
+			await withAuthorize(ctx, existing, "delete");
+			if (!existing) throw new Error("Resource not found or access denied");
+			if (h.beforeDelete) await h.beforeDelete(ctx, input, existing);
+			let deleted;
+			if (softDelete) [deleted] = await ctx.db.update(table).set({ [softDelete.column]: softDelete.getValue() }).where(where).returning();
+			else [deleted] = await ctx.db.delete(table).where(where).returning();
+			if (h.afterDelete) await h.afterDelete(ctx, deleted);
 			return deleted;
 		}),
-		deleteMany: baseProcedure.input(zod.z.array(zod.z.string()).max(maxBatchSize, `Maximum ${maxBatchSize} items allowed`)).mutation(async ({ ctx, input }) => {
-			await withAuthorize("deleteMany", input);
-			const column = getIdColumn();
-			return { deleted: (await ctx.db.delete(table).where((0, drizzle_orm.inArray)(column, input)).returning()).length };
+		deleteMany: resolved.procedureFactory("deleteMany").input(zod.z.array(zod.z.string()).max(maxBatchSize)).mutation(async ({ ctx, input }) => {
+			await withGuard(ctx, "deleteMany");
+			if (h.beforeDeleteMany) await h.beforeDeleteMany(ctx, input);
+			const where = buildWhere(ctx, "deleteMany", (0, drizzle_orm.inArray)(getIdColumn(), input));
+			let result;
+			if (softDelete) result = { deleted: (await ctx.db.update(table).set({ [softDelete.column]: softDelete.getValue() }).where(where).returning()).length };
+			else result = { deleted: (await ctx.db.delete(table).where(where).returning()).length };
+			if (h.afterDeleteMany) await h.afterDeleteMany(ctx, result);
+			return result;
 		}),
-		updateMany: baseProcedure.input(zod.z.object({
-			ids: zod.z.array(zod.z.string()).max(maxBatchSize, `Maximum ${maxBatchSize} items allowed`),
+		updateMany: resolved.procedureFactory("updateMany").input(zod.z.object({
+			ids: zod.z.array(zod.z.string()).max(maxBatchSize),
 			data: updateSchema
 		})).mutation(async ({ ctx, input }) => {
-			await withAuthorize("updateMany", input);
-			const column = getIdColumn();
-			return { updated: (await ctx.db.update(table).set(input.data).where((0, drizzle_orm.inArray)(column, input.ids)).returning()).length };
+			await withGuard(ctx, "updateMany");
+			let processedData = input.data;
+			if (h.beforeUpdateMany) {
+				const result$1 = await h.beforeUpdateMany(ctx, input.ids, processedData);
+				if (result$1) processedData = result$1;
+			}
+			const where = buildWhere(ctx, "updateMany", (0, drizzle_orm.inArray)(getIdColumn(), input.ids));
+			const injectData = resolved.getInject(ctx, "update");
+			const data = {
+				...processedData,
+				...injectData
+			};
+			const result = { updated: (await ctx.db.update(table).set(data).where(where).returning()).length };
+			if (h.afterUpdateMany) await h.afterUpdateMany(ctx, result);
+			return result;
 		})
-	});
+	};
+	const crudRouter = router(procedures);
+	return Object.assign(crudRouter, { procedures });
 }
 
 //#endregion