@wordrhyme/auto-crud-server 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,172 @@
+import { z } from "zod";
+import * as _trpc_server2 from "@trpc/server";
+import superjson from "superjson";
+import { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import { PgTable } from "drizzle-orm/pg-core";
+
+//#region src/trpc.d.ts
+/**
+ * tRPC Context 类型
+ * 消费者需要提供包含 db 的 context
+ */
+interface Context {
+  db: PostgresJsDatabase<Record<string, never>>;
+}
+declare const t: _trpc_server2.TRPCRootObject<Context, object, {
+  transformer: typeof superjson;
+}, {
+  ctx: Context;
+  meta: object;
+  errorShape: _trpc_server2.TRPCDefaultErrorShape;
+  transformer: true;
+}>;
+declare const router: _trpc_server2.TRPCRouterBuilder<{
+  ctx: Context;
+  meta: object;
+  errorShape: _trpc_server2.TRPCDefaultErrorShape;
+  transformer: true;
+}>;
+declare const publicProcedure: _trpc_server2.TRPCProcedureBuilder<Context, object, object, _trpc_server2.TRPCUnsetMarker, _trpc_server2.TRPCUnsetMarker, _trpc_server2.TRPCUnsetMarker, _trpc_server2.TRPCUnsetMarker, false>;
+type AnyProcedure = typeof t.procedure;
+//#endregion
+//#region src/routers/_factory.d.ts
+/**
+ * 授权回调类型
+ * 返回 true 允许操作，返回 false 或抛出错误拒绝操作
+ */
+type AuthorizeCallback = (ctx: {
+  operation: "list" | "get" | "create" | "update" | "delete" | "deleteMany" | "updateMany";
+  input?: unknown;
+}) => boolean | Promise<boolean>;
+/**
+ * CRUD Router 配置
+ */
+interface CrudRouterConfig {
+  table: PgTable;
+  selectSchema: z.ZodType;
+  insertSchema: z.ZodType;
+  updateSchema: z.ZodType;
+  idField?: string;
+  /**
+   * 可过滤的列白名单
+   * 未指定时默认允许所有列（不安全，仅用于开发）
+   */
+  filterableColumns?: string[];
+  /**
+   * 可排序的列白名单
+   * 未指定时默认允许所有列（不安全，仅用于开发）
+   */
+  sortableColumns?: string[];
+  /**
+   * 批量操作的最大数量限制
+   * 默认: 100
+   */
+  maxBatchSize?: number;
+  /**
+   * 自定义 procedure（用于注入授权中间件）
+   * 默认使用 publicProcedure
+   */
+  procedure?: AnyProcedure;
+  /**
+   * 授权回调（简单场景下的快捷授权方式）
+   * 如果需要更复杂的授权逻辑，建议使用 procedure 注入中间件
+   */
+  authorize?: AuthorizeCallback;
+}
+/**
+ * 创建通用 CRUD Router
+ */
+declare function createCrudRouter(config: CrudRouterConfig): _trpc_server2.TRPCBuiltRouter<{
+  ctx: Context;
+  meta: object;
+  errorShape: _trpc_server2.TRPCDefaultErrorShape;
+  transformer: true;
+}, _trpc_server2.TRPCDecorateCreateRouterOptions<{
+  list: _trpc_server2.TRPCQueryProcedure<{
+    input: {
+      page?: number | undefined;
+      perPage?: number | undefined;
+      sort?: {
+        id: string;
+        desc: boolean;
+      }[] | undefined;
+      filters?: {
+        id: string;
+        value: string | string[];
+        variant: "number" | "boolean" | "date" | "text" | "range" | "dateRange" | "select" | "multiSelect";
+        operator: "iLike" | "notILike" | "eq" | "ne" | "isEmpty" | "isNotEmpty" | "lt" | "lte" | "gt" | "gte" | "isBetween" | "isRelativeToToday" | "inArray" | "notInArray";
+        filterId: string;
+      }[] | undefined;
+      joinOperator?: "and" | "or" | undefined;
+    };
+    output: {
+      data: {
+        [x: string]: unknown;
+      }[];
+      total: number;
+      page: number;
+      perPage: number;
+      pageCount: number;
+    };
+    meta: object;
+  }>;
+  getById: _trpc_server2.TRPCQueryProcedure<{
+    input: string;
+    output: {
+      [x: string]: unknown;
+    } | null;
+    meta: object;
+  }>;
+  create: _trpc_server2.TRPCMutationProcedure<{
+    input: unknown;
+    output: {
+      [x: string]: unknown;
+    } | undefined;
+    meta: object;
+  }>;
+  update: _trpc_server2.TRPCMutationProcedure<{
+    input: {
+      id: string;
+      data: unknown;
+    };
+    output: {
+      [x: string]: unknown;
+    } | undefined;
+    meta: object;
+  }>;
+  delete: _trpc_server2.TRPCMutationProcedure<{
+    input: string;
+    output: {
+      [x: string]: unknown;
+    } | undefined;
+    meta: object;
+  }>;
+  deleteMany: _trpc_server2.TRPCMutationProcedure<{
+    input: string[];
+    output: {
+      deleted: number;
+    };
+    meta: object;
+  }>;
+  updateMany: _trpc_server2.TRPCMutationProcedure<{
+    input: {
+      ids: string[];
+      data: unknown;
+    };
+    output: {
+      updated: number;
+    };
+    meta: object;
+  }>;
+}>>;
+//#endregion
+//#region src/routers/index.d.ts
+declare const appRouter: _trpc_server2.TRPCBuiltRouter<{
+  ctx: Context;
+  meta: object;
+  errorShape: _trpc_server2.TRPCDefaultErrorShape;
+  transformer: true;
+}, _trpc_server2.TRPCDecorateCreateRouterOptions<{}>>;
+type AppRouter = typeof appRouter;
+//#endregion
+export { type AnyProcedure, type AppRouter, type AuthorizeCallback, type CrudRouterConfig, appRouter, createCrudRouter, publicProcedure, router };

package/dist/index.js

@@ -0,0 +1,498 @@
+import { z } from "zod";
+import { and, asc, desc, eq, gt, gte, ilike, inArray, isNull, lt, lte, ne, not, notIlike, notInArray, or, sql } from "drizzle-orm";
+import { initTRPC } from "@trpc/server";
+import superjson from "superjson";
+import { addDays, endOfDay, startOfDay } from "date-fns";
+
+//#region src/trpc.ts
+const t = initTRPC.context().create({ transformer: superjson });
+const router = t.router;
+const publicProcedure = t.procedure;
+
+//#endregion
+//#region src/lib/filter-columns.ts
+/**
+* 检查列是否为空
+*/
+function isEmpty(column) {
+	return or(isNull(column), eq(column, ""));
+}
+/**
+* 安全解析日期时间戳
+* @returns Date 对象，如果解析失败返回 null
+*/
+function safeParseDate(value) {
+	if (value === void 0 || value === null || value === "") return null;
+	const timestamp = typeof value === "string" ? Number(value) : value;
+	if (Number.isNaN(timestamp)) return null;
+	const date = new Date(timestamp);
+	if (Number.isNaN(date.getTime())) return null;
+	return date;
+}
+/**
+* 安全解析数字
+* @returns number，如果解析失败返回 null
+*/
+function safeParseNumber(value) {
+	if (value === void 0 || value === null || value.trim() === "") return null;
+	const num = Number(value);
+	return Number.isNaN(num) ? null : num;
+}
+function filterColumns({ table, filters, joinOperator }) {
+	const joinFn = joinOperator === "and" ? and : or;
+	const validConditions = filters.map((filter) => {
+		const column = getColumn(table, filter.id);
+		switch (filter.operator) {
+			case "iLike": return filter.variant === "text" && typeof filter.value === "string" ? ilike(column, `%${filter.value}%`) : void 0;
+			case "notILike": return filter.variant === "text" && typeof filter.value === "string" ? notIlike(column, `%${filter.value}%`) : void 0;
+			case "eq":
+				if (column.dataType === "boolean" && typeof filter.value === "string") return eq(column, filter.value === "true");
+				if (filter.variant === "dateRange" && Array.isArray(filter.value) && filter.value.length === 2) {
+					const startDate = safeParseDate(filter.value[0]);
+					const endDate = safeParseDate(filter.value[1]);
+					if (!startDate && !endDate) return void 0;
+					if (startDate) startDate.setHours(0, 0, 0, 0);
+					if (endDate) endDate.setHours(23, 59, 59, 999);
+					return and(startDate ? gte(column, startDate) : void 0, endDate ? lte(column, endDate) : void 0);
+				}
+				if (filter.variant === "date" && typeof filter.value === "string") {
+					const date = safeParseDate(filter.value);
+					if (!date) return void 0;
+					date.setHours(0, 0, 0, 0);
+					const end = new Date(date);
+					end.setHours(23, 59, 59, 999);
+					return and(gte(column, date), lte(column, end));
+				}
+				return eq(column, filter.value);
+			case "ne":
+				if (column.dataType === "boolean" && typeof filter.value === "string") return ne(column, filter.value === "true");
+				if (filter.variant === "date" || filter.variant === "dateRange") {
+					const date = safeParseDate(filter.value);
+					if (!date) return void 0;
+					date.setHours(0, 0, 0, 0);
+					const end = new Date(date);
+					end.setHours(23, 59, 59, 999);
+					return or(lt(column, date), gt(column, end));
+				}
+				return ne(column, filter.value);
+			case "inArray":
+				if (Array.isArray(filter.value)) return inArray(column, filter.value);
+				return;
+			case "notInArray":
+				if (Array.isArray(filter.value)) return notInArray(column, filter.value);
+				return;
+			case "lt":
+				if (filter.variant === "number" || filter.variant === "range") {
+					const num = safeParseNumber(filter.value);
+					return num !== null ? lt(column, num) : void 0;
+				}
+				if (filter.variant === "date" && typeof filter.value === "string") {
+					const date = safeParseDate(filter.value);
+					if (!date) return void 0;
+					date.setHours(23, 59, 59, 999);
+					return lt(column, date);
+				}
+				return;
+			case "lte":
+				if (filter.variant === "number" || filter.variant === "range") {
+					const num = safeParseNumber(filter.value);
+					return num !== null ? lte(column, num) : void 0;
+				}
+				if (filter.variant === "date" && typeof filter.value === "string") {
+					const date = safeParseDate(filter.value);
+					if (!date) return void 0;
+					date.setHours(23, 59, 59, 999);
+					return lte(column, date);
+				}
+				return;
+			case "gt":
+				if (filter.variant === "number" || filter.variant === "range") {
+					const num = safeParseNumber(filter.value);
+					return num !== null ? gt(column, num) : void 0;
+				}
+				if (filter.variant === "date" && typeof filter.value === "string") {
+					const date = safeParseDate(filter.value);
+					if (!date) return void 0;
+					date.setHours(0, 0, 0, 0);
+					return gt(column, date);
+				}
+				return;
+			case "gte":
+				if (filter.variant === "number" || filter.variant === "range") {
+					const num = safeParseNumber(filter.value);
+					return num !== null ? gte(column, num) : void 0;
+				}
+				if (filter.variant === "date" && typeof filter.value === "string") {
+					const date = safeParseDate(filter.value);
+					if (!date) return void 0;
+					date.setHours(0, 0, 0, 0);
+					return gte(column, date);
+				}
+				return;
+			case "isBetween":
+				if ((filter.variant === "date" || filter.variant === "dateRange") && Array.isArray(filter.value) && filter.value.length === 2) {
+					const startDate = safeParseDate(filter.value[0]);
+					const endDate = safeParseDate(filter.value[1]);
+					if (!startDate && !endDate) return void 0;
+					if (startDate) startDate.setHours(0, 0, 0, 0);
+					if (endDate) endDate.setHours(23, 59, 59, 999);
+					return and(startDate ? gte(column, startDate) : void 0, endDate ? lte(column, endDate) : void 0);
+				}
+				if ((filter.variant === "number" || filter.variant === "range") && Array.isArray(filter.value) && filter.value.length === 2) {
+					const firstValue = safeParseNumber(filter.value[0]);
+					const secondValue = safeParseNumber(filter.value[1]);
+					if (firstValue === null && secondValue === null) return;
+					if (firstValue !== null && secondValue === null) return eq(column, firstValue);
+					if (firstValue === null && secondValue !== null) return eq(column, secondValue);
+					return and(firstValue !== null ? gte(column, firstValue) : void 0, secondValue !== null ? lte(column, secondValue) : void 0);
+				}
+				return;
+			case "isRelativeToToday":
+				if ((filter.variant === "date" || filter.variant === "dateRange") && typeof filter.value === "string") {
+					const today = /* @__PURE__ */ new Date();
+					const [amount, unit] = filter.value.split(" ") ?? [];
+					let startDate;
+					let endDate;
+					if (!amount || !unit) return void 0;
+					switch (unit) {
+						case "days":
+							startDate = startOfDay(addDays(today, Number.parseInt(amount, 10)));
+							endDate = endOfDay(startDate);
+							break;
+						case "weeks":
+							startDate = startOfDay(addDays(today, Number.parseInt(amount, 10) * 7));
+							endDate = endOfDay(addDays(startDate, 6));
+							break;
+						case "months":
+							startDate = startOfDay(addDays(today, Number.parseInt(amount, 10) * 30));
+							endDate = endOfDay(addDays(startDate, 29));
+							break;
+						default: return;
+					}
+					return and(gte(column, startDate), lte(column, endDate));
+				}
+				return;
+			case "isEmpty": return isEmpty(column);
+			case "isNotEmpty": return not(isEmpty(column));
+			default: throw new Error(`Unsupported operator: ${filter.operator}`);
+		}
+	}).filter((condition) => condition !== void 0);
+	return validConditions.length > 0 ? joinFn(...validConditions) : void 0;
+}
+function getColumn(table, columnKey) {
+	return table[columnKey];
+}
+
+//#endregion
+//#region src/config/data-table.ts
+const dataTableConfig = {
+	textOperators: [
+		{
+			label: "Contains",
+			value: "iLike"
+		},
+		{
+			label: "Does not contain",
+			value: "notILike"
+		},
+		{
+			label: "Is",
+			value: "eq"
+		},
+		{
+			label: "Is not",
+			value: "ne"
+		},
+		{
+			label: "Is empty",
+			value: "isEmpty"
+		},
+		{
+			label: "Is not empty",
+			value: "isNotEmpty"
+		}
+	],
+	numericOperators: [
+		{
+			label: "Is",
+			value: "eq"
+		},
+		{
+			label: "Is not",
+			value: "ne"
+		},
+		{
+			label: "Is less than",
+			value: "lt"
+		},
+		{
+			label: "Is less than or equal to",
+			value: "lte"
+		},
+		{
+			label: "Is greater than",
+			value: "gt"
+		},
+		{
+			label: "Is greater than or equal to",
+			value: "gte"
+		},
+		{
+			label: "Is between",
+			value: "isBetween"
+		},
+		{
+			label: "Is empty",
+			value: "isEmpty"
+		},
+		{
+			label: "Is not empty",
+			value: "isNotEmpty"
+		}
+	],
+	dateOperators: [
+		{
+			label: "Is",
+			value: "eq"
+		},
+		{
+			label: "Is not",
+			value: "ne"
+		},
+		{
+			label: "Is before",
+			value: "lt"
+		},
+		{
+			label: "Is after",
+			value: "gt"
+		},
+		{
+			label: "Is on or before",
+			value: "lte"
+		},
+		{
+			label: "Is on or after",
+			value: "gte"
+		},
+		{
+			label: "Is between",
+			value: "isBetween"
+		},
+		{
+			label: "Is relative to today",
+			value: "isRelativeToToday"
+		},
+		{
+			label: "Is empty",
+			value: "isEmpty"
+		},
+		{
+			label: "Is not empty",
+			value: "isNotEmpty"
+		}
+	],
+	selectOperators: [
+		{
+			label: "Is",
+			value: "eq"
+		},
+		{
+			label: "Is not",
+			value: "ne"
+		},
+		{
+			label: "Is empty",
+			value: "isEmpty"
+		},
+		{
+			label: "Is not empty",
+			value: "isNotEmpty"
+		}
+	],
+	multiSelectOperators: [
+		{
+			label: "Has any of",
+			value: "inArray"
+		},
+		{
+			label: "Has none of",
+			value: "notInArray"
+		},
+		{
+			label: "Is empty",
+			value: "isEmpty"
+		},
+		{
+			label: "Is not empty",
+			value: "isNotEmpty"
+		}
+	],
+	booleanOperators: [{
+		label: "Is",
+		value: "eq"
+	}, {
+		label: "Is not",
+		value: "ne"
+	}],
+	sortOrders: [{
+		label: "Asc",
+		value: "asc"
+	}, {
+		label: "Desc",
+		value: "desc"
+	}],
+	filterVariants: [
+		"text",
+		"number",
+		"range",
+		"date",
+		"dateRange",
+		"boolean",
+		"select",
+		"multiSelect"
+	],
+	operators: [
+		"iLike",
+		"notILike",
+		"eq",
+		"ne",
+		"inArray",
+		"notInArray",
+		"isEmpty",
+		"isNotEmpty",
+		"lt",
+		"lte",
+		"gt",
+		"gte",
+		"isBetween",
+		"isRelativeToToday"
+	],
+	joinOperators: ["and", "or"]
+};
+
+//#endregion
+//#region src/routers/_factory.ts
+/**
+* 过滤器项 Schema
+*/
+const filterItemSchema = z.object({
+	id: z.string(),
+	value: z.union([z.string(), z.array(z.string())]),
+	variant: z.enum(dataTableConfig.filterVariants),
+	operator: z.enum(dataTableConfig.operators),
+	filterId: z.string()
+});
+/**
+* 列表查询输入 Schema
+*/
+const listInputSchema = z.object({
+	page: z.number().min(1).default(1),
+	perPage: z.number().min(1).max(100).default(10),
+	sort: z.array(z.object({
+		id: z.string(),
+		desc: z.boolean()
+	})).optional(),
+	filters: z.array(filterItemSchema).optional(),
+	joinOperator: z.enum(["and", "or"]).default("and")
+});
+/**
+* 验证列是否在白名单中
+*/
+function validateColumn(columnId, allowedColumns, columnType) {
+	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 getIdColumn = () => table[idField];
+	const withAuthorize = async (operation, input) => {
+		if (authorize) {
+			if (!await authorize({
+				operation,
+				input
+			})) throw new Error(`Unauthorized: ${operation} 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({
+				table,
+				filters: validatedFilters,
+				joinOperator: input.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")) {
+					const column = table[sortField.id];
+					if (column) query = query.orderBy(sortField.desc ? desc(column) : asc(column));
+				}
+			}
+			const data = await query.limit(input.perPage).offset(offset);
+			let countQuery = ctx.db.select({ count: sql`count(*)::int` }).from(table).$dynamic();
+			if (where) countQuery = countQuery.where(where);
+			const count = (await countQuery)[0]?.count ?? 0;
+			return {
+				data,
+				total: count,
+				page: input.page,
+				perPage: input.perPage,
+				pageCount: Math.ceil(count / input.perPage)
+			};
+		}),
+		getById: baseProcedure.input(z.string()).query(async ({ ctx, input }) => {
+			await withAuthorize("get", input);
+			const column = getIdColumn();
+			const [item] = await ctx.db.select().from(table).where(eq(column, input));
+			return item ?? null;
+		}),
+		create: baseProcedure.input(insertSchema).mutation(async ({ ctx, input }) => {
+			await withAuthorize("create", input);
+			const [created] = await ctx.db.insert(table).values(input).returning();
+			return created;
+		}),
+		update: baseProcedure.input(z.object({
+			id: 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(eq(column, input.id)).returning();
+			return updated;
+		}),
+		delete: baseProcedure.input(z.string()).mutation(async ({ ctx, input }) => {
+			await withAuthorize("delete", input);
+			const column = getIdColumn();
+			const [deleted] = await ctx.db.delete(table).where(eq(column, input)).returning();
+			return deleted;
+		}),
+		deleteMany: baseProcedure.input(z.array(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(inArray(column, input)).returning()).length };
+		}),
+		updateMany: baseProcedure.input(z.object({
+			ids: z.array(z.string()).max(maxBatchSize, `Maximum ${maxBatchSize} items allowed`),
+			data: updateSchema
+		})).mutation(async ({ ctx, input }) => {
+			await withAuthorize("updateMany", input);
+			const column = getIdColumn();
+			return { updated: (await ctx.db.update(table).set(input.data).where(inArray(column, input.ids)).returning()).length };
+		})
+	});
+}
+
+//#endregion
+//#region src/routers/index.ts
+const appRouter = router({});
+
+//#endregion
+export { appRouter, createCrudRouter, publicProcedure, router };