@wordrhyme/auto-crud-server 0.8.0 → 0.10.0

package/dist/index.js

@@ -1,5 +1,6 @@
 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 { createInsertSchema, createSelectSchema } from "drizzle-zod";
 import { TRPCError, initTRPC } from "@trpc/server";
 import superjson from "superjson";
 import { addDays, endOfDay, startOfDay } from "date-fns";
@@ -371,6 +372,26 @@ const dataTableConfig = {
 	joinOperators: ["and", "or"]
 };
 
+//#endregion
+//#region src/lib/schema-utils.ts
+/**
+* 检查是否为 ZodObject 类型
+* 兼容 Zod v3 和 v4
+*
+* 实现策略：检查 schema 是否具有 ZodObject 特有的 .shape 属性
+* 这种方式比检查内部 _def 属性更稳定，因为不依赖 Zod 的内部实现细节
+*/
+function isZodObject(schema) {
+	return schema !== null && typeof schema === "object" && "shape" in schema && typeof schema.shape === "object" && schema.shape !== null;
+}
+/**
+* 非空对象验证器
+* 用于 updateSchema 的 refine，防止空更新
+*/
+function nonEmpty(value) {
+	return Object.keys(value).length > 0;
+}
+
 //#endregion
 //#region src/routers/_factory.ts
 function resolveSoftDelete(option) {
@@ -406,6 +427,9 @@ function isProcedureMap(config) {
 			"deleteMany",
 			"updateMany",
 			"upsert",
+			"export",
+			"import",
+			"createMany",
 			"default"
 		];
 		return keys.some((k) => validKeys.includes(k));
@@ -457,20 +481,63 @@ const listInputSchema = z.object({
 	filters: z.array(filterItemSchema).optional(),
 	joinOperator: z.enum(["and", "or"]).default("and")
 });
+const exportInputSchema = z.object({
+	sort: z.array(z.object({
+		id: z.string(),
+		desc: z.boolean()
+	})).optional(),
+	filters: z.array(filterItemSchema).optional(),
+	joinOperator: z.enum(["and", "or"]).default("and"),
+	limit: z.number().min(1).optional()
+});
+const importInputSchema = z.object({
+	rows: z.array(z.unknown()).min(1).max(1e3),
+	onConflict: z.enum([
+		"skip",
+		"upsert",
+		"error"
+	]).default("skip")
+});
+const DEFAULT_OMIT_FIELDS = [
+	"id",
+	"createdAt",
+	"updatedAt"
+];
+/**
+* 解析并派生 Schema
+* - 优先使用显式传入的 Schema
+* - 否则从 Drizzle table 自动派生
+*/
+function resolveSchemas(config) {
+	const { table, omitFields = DEFAULT_OMIT_FIELDS } = config;
+	let schema;
+	if (config.schema) {
+		if (!isZodObject(config.schema)) throw new Error("[createCrudRouter] schema must be a ZodObject (not ZodEffects or other types). If you're using .refine() or .transform(), please remove them from schema.");
+		schema = config.schema;
+	} else {
+		const rawSchema = createInsertSchema(table);
+		if (!isZodObject(rawSchema)) throw new Error("[createCrudRouter] drizzle-zod returned non-ZodObject schema. This may be due to table refinements. Please provide schema explicitly.");
+		const omitConfig = Object.fromEntries(omitFields.map((f) => [f, true]));
+		schema = rawSchema.omit(omitConfig);
+	}
+	let selectSchema;
+	if (config.selectSchema) selectSchema = config.selectSchema;
+	else if (config.schema) selectSchema = schema;
+	else selectSchema = createSelectSchema(table);
+	const updateSchema = config.updateSchema ?? schema.partial().refine(nonEmpty, { message: "Update payload cannot be empty. At least one field is required." });
+	return {
+		selectSchema,
+		schema,
+		updateSchema
+	};
+}
 function validateColumn(columnId, allowedColumns) {
 	if (!allowedColumns || allowedColumns.length === 0) return true;
 	return allowedColumns.includes(columnId);
 }
-/**
-* 创建 CRUD Router
-*
-* @typeParam TContext - 上下文类型（包含 db）
-* @typeParam TSelect - 查询返回类型（从 selectSchema 或 insertSchema 推断）
-* @typeParam TInsert - 创建输入类型（从 insertSchema 推断）
-* @typeParam TUpdate - 更新输入类型（从 updateSchema 推断）
-*/
 function createCrudRouter(config) {
-	const { table, insertSchema, updateSchema, idField = "id", filterableColumns, sortableColumns, maxBatchSize = 100, softDelete: softDeleteOption, middleware = {} } = config;
+	const { table, idField = "id", filterableColumns, sortableColumns, maxBatchSize = 100, maxExportSize = 5e3, softDelete: softDeleteOption, middleware = {} } = config;
+	const { schema, updateSchema } = resolveSchemas(config);
 	const resolved = resolveConfig(config);
 	const softDelete = resolveSoftDelete(softDeleteOption);
 	const m = middleware;
@@ -568,7 +635,7 @@ function createCrudRouter(config) {
 			});
 			return doGet();
 		}),
-		create: resolved.procedureFactory("create").input(insertSchema).mutation(async ({ ctx, input }) => {
+		create: resolved.procedureFactory("create").input(schema).mutation(async ({ ctx, input }) => {
 			await withGuard(ctx, "create");
 			const doCreate = async (inputData) => {
 				const injectData = resolved.getInject(ctx, "create");
@@ -675,7 +742,7 @@ function createCrudRouter(config) {
 			});
 			return doUpdateMany(input.data);
 		}),
-		upsert: resolved.procedureFactory("upsert").input(insertSchema).mutation(async ({ ctx, input }) => {
+		upsert: resolved.procedureFactory("upsert").input(schema).mutation(async ({ ctx, input }) => {
 			await withGuard(ctx, "upsert");
 			const doUpsert = async (inputData) => {
 				const inputId = inputData[idField];
@@ -711,6 +778,131 @@ function createCrudRouter(config) {
 				next: async (modifiedInput) => doUpsert(modifiedInput ?? input)
 			});
 			return doUpsert(input);
+		}),
+		export: resolved.procedureFactory("export").input(exportInputSchema).query(async ({ ctx, input }) => {
+			await withGuard(ctx, "export");
+			const doExport = async (exportInput$1) => {
+				const effectiveLimit = Math.min(Math.max(exportInput$1.limit ?? maxExportSize, 1), maxExportSize);
+				const validatedFilters = exportInput$1.filters?.filter((filter) => validateColumn(filter.id, filterableColumns));
+				const where = buildWhere(ctx, "export", validatedFilters?.length ? filterColumns({
+					table,
+					filters: validatedFilters,
+					joinOperator: exportInput$1.joinOperator ?? "and"
+				}) : void 0);
+				let query = ctx.db.select().from(table).$dynamic();
+				if (where) query = query.where(where);
+				if (exportInput$1.sort?.length) {
+					const sortField = exportInput$1.sort[0];
+					if (sortField && validateColumn(sortField.id, sortableColumns)) {
+						const column = table[sortField.id];
+						if (column) query = query.orderBy(sortField.desc ? desc(column) : asc(column));
+					}
+				}
+				const data = await query.limit(effectiveLimit);
+				let countQuery = ctx.db.select({ count: sql`count(*)::int` }).from(table).$dynamic();
+				if (where) countQuery = countQuery.where(where);
+				const total = (await countQuery)[0]?.count ?? 0;
+				return {
+					data,
+					total,
+					hasMore: total > data.length
+				};
+			};
+			const exportInput = input;
+			if (m.export) return m.export({
+				ctx,
+				input: exportInput,
+				next: async (modifiedInput) => doExport(modifiedInput ?? exportInput)
+			});
+			return doExport(exportInput);
+		}),
+		createMany: resolved.procedureFactory("createMany").input(z.array(schema).min(1).max(maxBatchSize)).mutation(async ({ ctx, input }) => {
+			await withGuard(ctx, "createMany");
+			const doCreateMany = async (items) => {
+				const injectData = resolved.getInject(ctx, "create");
+				const values = items.map((item) => ({
+					...item,
+					...injectData
+				}));
+				const created = await ctx.db.insert(table).values(values).onConflictDoNothing().returning();
+				return {
+					created,
+					count: created.length
+				};
+			};
+			if (m.createMany) return m.createMany({
+				ctx,
+				input,
+				next: async (modifiedInput) => doCreateMany(modifiedInput ?? input)
+			});
+			return doCreateMany(input);
+		}),
+		import: resolved.procedureFactory("import").input(importInputSchema).mutation(async ({ ctx, input }) => {
+			await withGuard(ctx, "import");
+			const doImport = async (importData$1) => {
+				const validRows = [];
+				const failed = [];
+				for (let i = 0; i < importData$1.rows.length; i++) {
+					const row = importData$1.rows[i];
+					const result = schema.safeParse(row);
+					if (result.success) validRows.push(result.data);
+					else {
+						const errors = result.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`);
+						failed.push({
+							row: i,
+							errors
+						});
+						if (importData$1.onConflict === "error") return {
+							success: 0,
+							updated: 0,
+							skipped: 0,
+							failed
+						};
+					}
+				}
+				if (validRows.length === 0) return {
+					success: 0,
+					updated: 0,
+					skipped: 0,
+					failed
+				};
+				const injectData = resolved.getInject(ctx, "create");
+				const values = validRows.map((row) => ({
+					...row,
+					...injectData
+				}));
+				let insertedCount = 0;
+				let updatedCount = 0;
+				if (importData$1.onConflict === "upsert") {
+					const existingCount = (await ctx.db.select({ id: getIdColumn() }).from(table).where(inArray(getIdColumn(), values.map((v) => v[idField]).filter(Boolean)))).length;
+					const updateFields = Object.keys(validRows[0]);
+					const setClause = { ...resolved.getInject(ctx, "update") };
+					for (const key of updateFields) setClause[key] = sql.raw(`excluded."${key}"`);
+					const results = await ctx.db.insert(table).values(values).onConflictDoUpdate({
+						target: getIdColumn(),
+						set: setClause
+					}).returning({ id: getIdColumn() });
+					updatedCount = Math.min(existingCount, results.length);
+					insertedCount = results.length - updatedCount;
+				} else {
+					insertedCount = (await ctx.db.insert(table).values(values).onConflictDoNothing().returning({ id: getIdColumn() })).length;
+					updatedCount = 0;
+				}
+				const skipped = validRows.length - insertedCount - updatedCount;
+				return {
+					success: insertedCount,
+					updated: updatedCount,
+					skipped,
+					failed
+				};
+			};
+			const importData = input;
+			if (m.import) return m.import({
+				ctx,
+				input: importData,
+				next: async (modifiedInput) => doImport(modifiedInput ?? importData)
+			});
+			return doImport(importData);
 		})
 	};
 	const crudRouter = router(procedures);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@wordrhyme/auto-crud-server",
   "type": "module",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "tRPC server utilities for auto-crud - automatic CRUD routers for Drizzle ORM",
   "author": "wordrhyme",
   "license": "MIT",
@@ -31,16 +31,16 @@
   },
   "peerDependencies": {
     "@trpc/server": "^11.0.0",
-    "drizzle-orm": "^0.40.0",
-    "drizzle-zod": "^0.8.0",
+    "drizzle-orm": "^0.40.0 || ^1.0.0-beta",
+    "drizzle-zod": "^0.8.0 || ^1.0.0-beta",
     "superjson": "^2.0.0",
     "zod": "^3.0.0 || ^4.0.0"
   },
   "devDependencies": {
     "@trpc/server": "^11.0.0",
     "@types/node": "^22.19.3",
-    "drizzle-orm": "^0.45.1",
-    "drizzle-zod": "^0.8.3",
+    "drizzle-orm": "1.0.0-beta.15-859cf75",
+    "drizzle-zod": "1.0.0-beta.14-a36c63d",
     "eslint": "^9.39.2",
     "superjson": "^2.2.6",
     "tsdown": "^0.15.12",
@@ -48,10 +48,10 @@
     "vitest": "^4.0.18",
     "zod": "^4.1.13",
     "@internal/eslint-config": "0.3.0",
-    "@internal/prettier-config": "0.0.1",
     "@internal/tsconfig": "0.1.0",
+    "@internal/tsdown-config": "0.1.0",
     "@internal/vitest-config": "0.1.0",
-    "@internal/tsdown-config": "0.1.0"
+    "@internal/prettier-config": "0.0.1"
   },
   "prettier": "@internal/prettier-config",
   "scripts": {