@wordrhyme/auto-crud-server 1.0.6 → 1.0.8

package/dist/index.cjs

@@ -457,6 +457,7 @@ function isProcedureMap(config) {
 	if (typeof config === "object" && config !== null) {
 		const keys = Object.keys(config);
 		const validKeys = [
+			"meta",
 			"list",
 			"get",
 			"create",
@@ -502,6 +503,9 @@ function resolveConfig(config) {
 		}
 	};
 }
+function resolveMetaProcedure(config, fallback) {
+	return isProcedureMap(config) ? config.meta ?? fallback : fallback;
+}
 const filterItemSchema = zod.z.object({
 	id: zod.z.string(),
 	value: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]),
@@ -516,6 +520,7 @@ const baseListInputSchema = zod.z.object({
 		id: zod.z.string(),
 		desc: zod.z.boolean()
 	})).optional(),
+	search: zod.z.string().trim().optional(),
 	filters: zod.z.array(filterItemSchema).optional(),
 	joinOperator: zod.z.enum(["and", "or"]).default("and")
 });
@@ -526,6 +531,7 @@ const baseExportInputSchema = zod.z.object({
 		id: zod.z.string(),
 		desc: zod.z.boolean()
 	})).optional(),
+	search: zod.z.string().trim().optional(),
 	filters: zod.z.array(filterItemSchema).optional(),
 	joinOperator: zod.z.enum(["and", "or"]).default("and"),
 	limit: zod.z.number().min(1).optional()
@@ -543,6 +549,13 @@ const DEFAULT_OMIT_FIELDS = [
 	"createdAt",
 	"updatedAt"
 ];
+function shouldEnableCrudExtensionSchema(config) {
+	return Boolean(config.id) && config.extensions !== false;
+}
+function withCrudExtensionInput(schema, config) {
+	if (!shouldEnableCrudExtensionSchema(config) || !isZodObject(schema)) return schema;
+	return schema.passthrough();
+}
 /**
 * 解析并派生 Schema
 * - 优先使用显式传入的 Schema
@@ -560,11 +573,12 @@ function resolveSchemas(config) {
 		const omitConfig = Object.fromEntries(omitFields.map((f) => [f, true]));
 		schema = rawSchema.omit(omitConfig);
 	}
+	schema = withCrudExtensionInput(schema, config);
 	let selectSchema;
 	if (config.selectSchema) selectSchema = config.selectSchema;
 	else if (config.schema) selectSchema = schema;
 	else selectSchema = (0, drizzle_zod.createSelectSchema)(table);
-	const updateSchema = config.updateSchema ?? schema.partial().refine(nonEmpty, { message: "Update payload cannot be empty. At least one field is required." });
+	const updateSchema = config.updateSchema ? withCrudExtensionInput(config.updateSchema, config) : schema.partial().refine(nonEmpty, { message: "Update payload cannot be empty. At least one field is required." });
 	return {
 		selectSchema,
 		schema,
@@ -609,6 +623,197 @@ function resolveColumnTarget({ table, columnId, allowedColumns }) {
 	}
 	return getTableColumn(table, columnId);
 }
+const CRUD_EXTENSION_FILTER_ID = "auto-crud-extension-filter";
+const NO_CRUD_EXTENSION_MATCH = "__auto_crud_no_crud_extension_match__";
+function isObjectRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isCrudExtensionIdFilter(filter, idField) {
+	return filter.id === idField && filter.filterId === CRUD_EXTENSION_FILTER_ID;
+}
+function readCrudTarget(config) {
+	const id = config.id;
+	if (!id) return null;
+	return { id };
+}
+function resolveCrudExtensions(ctx, config) {
+	const extensions = config.extensions;
+	if (extensions === false) return null;
+	if (typeof extensions === "function") return extensions(ctx) ?? null;
+	if (extensions) return extensions;
+	if (!config.id) return null;
+	return ctx?.crudExtensions ?? null;
+}
+function getTableColumnNames(table) {
+	try {
+		const columns = (0, drizzle_orm.getTableColumns)(table);
+		const names = Object.keys(columns);
+		if (names.length > 0) return new Set(names);
+	} catch {}
+	return new Set(Object.keys(table).filter((key) => !key.startsWith("_")));
+}
+function splitCrudExtensionWriteInput(inputData, tableColumnNames) {
+	if (!isObjectRecord(inputData)) return {
+		data: inputData,
+		rawValues: {},
+		baseValues: {},
+		extraValues: null
+	};
+	const baseValues = {};
+	const extraValues = {};
+	for (const [key, value] of Object.entries(inputData)) {
+		if (key === "ext") {
+			if (isObjectRecord(value)) Object.assign(extraValues, value);
+			continue;
+		}
+		if (tableColumnNames.has(key)) baseValues[key] = value;
+		else extraValues[key] = value;
+	}
+	return {
+		data: baseValues,
+		rawValues: inputData,
+		baseValues,
+		extraValues: Object.keys(extraValues).length > 0 ? extraValues : null
+	};
+}
+async function saveCrudExtraValues(ctx, config, entityId, input) {
+	const target = readCrudTarget(config);
+	const extraValues = input.extraValues;
+	if (!target || !extraValues) return;
+	if (entityId === null || entityId === void 0 || String(entityId).length === 0) return;
+	const provider = resolveCrudExtensions(ctx, config);
+	if (!provider?.saveExtraValues) throw new __trpc_server.TRPCError({
+		code: "PRECONDITION_FAILED",
+		message: "CRUD extension persistence is not available"
+	});
+	await provider.saveExtraValues({
+		id: target.id,
+		entityId: String(entityId),
+		rawValues: input.rawValues,
+		baseValues: input.baseValues,
+		extraValues,
+		tx: ctx?.tx
+	});
+}
+function assertCrudExtraValuesWritable(ctx, config, input) {
+	if (!readCrudTarget(config) || !input.extraValues) return;
+	if (!resolveCrudExtensions(ctx, config)?.saveExtraValues) throw new __trpc_server.TRPCError({
+		code: "PRECONDITION_FAILED",
+		message: "CRUD extension persistence is not available"
+	});
+}
+function assertCrudExtraValuesWritableForRows(ctx, config, inputs) {
+	if (inputs.some((input) => input.extraValues)) assertCrudExtraValuesWritable(ctx, config, inputs.find((input) => input.extraValues));
+}
+async function saveCrudExtraValuesForRows(ctx, config, idField, results, inputs) {
+	const extraByInputId = /* @__PURE__ */ new Map();
+	for (const input of inputs) {
+		if (!input.extraValues || !isObjectRecord(input.data)) continue;
+		const inputId = input.data[idField];
+		if (inputId !== null && inputId !== void 0) extraByInputId.set(String(inputId), input);
+	}
+	const canUseIndexFallback = results.length === inputs.length;
+	await Promise.all(results.map((result, index) => {
+		const resultId = result[idField];
+		const fallbackInput = canUseIndexFallback ? inputs[index] : void 0;
+		const fallbackInputId = fallbackInput && isObjectRecord(fallbackInput.data) ? fallbackInput.data[idField] : void 0;
+		const entityId = resultId !== null && resultId !== void 0 ? resultId : fallbackInputId;
+		const input = entityId !== null && entityId !== void 0 ? extraByInputId.get(String(entityId)) ?? fallbackInput : fallbackInput;
+		return input ? saveCrudExtraValues(ctx, config, entityId, input) : Promise.resolve();
+	}));
+}
+function readProjectionDisplay(value) {
+	if (!isObjectRecord(value)) return value;
+	if ("display" in value && value.display !== null && value.display !== void 0) return value.display;
+	if ("value" in value) return value.value;
+	return value;
+}
+async function enrichCrudRows(ctx, config, idField, rows) {
+	const target = readCrudTarget(config);
+	if (!target || rows.length === 0) return rows;
+	const provider = resolveCrudExtensions(ctx, config);
+	if (!provider?.readProjection) return rows;
+	const entityIds = rows.map((row) => row[idField]).filter((id) => typeof id === "string" && id.length > 0 || typeof id === "number").map(String);
+	if (entityIds.length === 0) return rows;
+	const projections = await provider.readProjection({
+		id: target.id,
+		entityIds
+	});
+	return rows.map((row) => {
+		const rowId = row[idField];
+		const projected = rowId !== null && rowId !== void 0 ? projections[String(rowId)] : void 0;
+		if (!projected || Object.keys(projected).length === 0) return row;
+		return {
+			...row,
+			...Object.fromEntries(Object.entries(projected).map(([field, value]) => [field, readProjectionDisplay(value)]))
+		};
+	});
+}
+function isAllowedBaseCrudColumn(table, columnId, allowedColumns) {
+	if (allowedColumns && allowedColumns.length > 0) return resolveColumnTarget({
+		table,
+		columnId,
+		allowedColumns
+	}) !== void 0;
+	return getTableColumn(table, columnId) !== void 0;
+}
+function isKnownBaseCrudColumn(table, columnId, allowedColumns) {
+	return getTableColumn(table, columnId) !== void 0 || findColumnRef(columnId, allowedColumns) !== void 0;
+}
+async function applyCrudExtensionFilters(ctx, config, table, idField, filterableColumns, input) {
+	const target = readCrudTarget(config);
+	const filters = input.filters ?? [];
+	const search = typeof input.search === "string" ? input.search.trim() : "";
+	if (!target || filters.length === 0 && !search) return input;
+	const baseFilters = [];
+	const extensionFilters = [];
+	for (const filter of filters) if (isAllowedBaseCrudColumn(table, filter.id, filterableColumns)) baseFilters.push(filter);
+	else if (isKnownBaseCrudColumn(table, filter.id, filterableColumns)) continue;
+	else extensionFilters.push(filter);
+	if (extensionFilters.length === 0 && !search) return {
+		...input,
+		filters: baseFilters
+	};
+	const provider = resolveCrudExtensions(ctx, config);
+	const matchedSets = [];
+	if (extensionFilters.length > 0) {
+		if (!provider?.matchEntityIds) throw new __trpc_server.TRPCError({
+			code: "PRECONDITION_FAILED",
+			message: "CRUD extension filtering is not available"
+		});
+		const matchedIds$1 = await provider.matchEntityIds({
+			id: target.id,
+			filters: extensionFilters,
+			joinOperator: input.joinOperator,
+			limit: 5e3
+		});
+		matchedSets.push(new Set(matchedIds$1));
+	}
+	if (search && provider?.searchEntityIds) {
+		const matchedIds$1 = await provider.searchEntityIds({
+			id: target.id,
+			search,
+			limit: 5e3
+		});
+		matchedSets.push(new Set(matchedIds$1));
+	}
+	if (matchedSets.length === 0) return {
+		...input,
+		filters: baseFilters
+	};
+	let matchedIds = matchedSets[0] ? [...matchedSets[0]] : [];
+	for (const set of matchedSets.slice(1)) matchedIds = matchedIds.filter((id) => set.has(id));
+	return {
+		...input,
+		filters: [...baseFilters, {
+			id: idField,
+			value: matchedIds.length > 0 ? matchedIds : [NO_CRUD_EXTENSION_MATCH],
+			variant: "multiSelect",
+			operator: "inArray",
+			filterId: CRUD_EXTENSION_FILTER_ID
+		}]
+	};
+}
 /**
 * 创建 CRUD Router
 *
@@ -624,14 +829,19 @@ function resolveColumnTarget({ table, columnId, allowedColumns }) {
 function createCrudRouter(config) {
 	const { table, idField = "id", filterableColumns, sortableColumns, maxBatchSize = 100, maxExportSize = 5e3, softDelete: softDeleteOption, middleware = {} } = config;
 	const { selectSchema, schema, updateSchema } = resolveSchemas(config);
-	const entityOutputSchema = selectSchema;
+	const entityOutputSchema = withCrudExtensionInput(selectSchema, config);
 	const listOutputSchema = zod.z.object({
-		data: zod.z.array(selectSchema),
+		data: zod.z.array(entityOutputSchema),
 		total: zod.z.number(),
 		page: zod.z.number(),
 		perPage: zod.z.number(),
 		pageCount: zod.z.number()
 	});
+	const metadataOutputSchema = zod.z.object({
+		schema: zod.z.unknown().optional(),
+		fields: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+		errors: zod.z.array(zod.z.string()).optional()
+	});
 	const deleteManyOutputSchema = zod.z.object({ deleted: zod.z.number() });
 	const updateManyOutputSchema = zod.z.object({ updated: zod.z.number() });
 	const upsertOutputSchema = zod.z.object({
@@ -639,12 +849,12 @@ function createCrudRouter(config) {
 		isNew: zod.z.boolean()
 	});
 	const exportOutputSchema = zod.z.object({
-		data: zod.z.array(selectSchema),
+		data: zod.z.array(entityOutputSchema),
 		total: zod.z.number(),
 		hasMore: zod.z.boolean()
 	});
 	const createManyOutputSchema = zod.z.object({
-		created: zod.z.array(selectSchema),
+		created: zod.z.array(entityOutputSchema),
 		count: zod.z.number()
 	});
 	const importOutputSchema = zod.z.object({
@@ -657,12 +867,14 @@ function createCrudRouter(config) {
 		}))
 	});
 	const resolved = resolveConfig(config);
+	const metaProcedure = resolveMetaProcedure(config.procedure, resolved.procedureFactory("list"));
 	const softDelete = resolveSoftDelete(softDeleteOption);
 	const resolvedListInputSchema = config.listInputSchema ?? baseListInputSchema;
 	const resolvedGetInputSchema = config.getInputSchema ? zod.z.union([zod.z.string(), config.getInputSchema]) : defaultGetInputSchema;
 	const resolvedExportInputSchema = config.exportInputSchema ?? baseExportInputSchema;
 	const m = middleware;
 	const getIdColumn = () => table[idField];
+	const tableColumnNames = getTableColumnNames(table);
 	const getSoftDeleteColumn = () => softDelete ? table[softDelete.column] : null;
 	const buildWhere = (ctx, operation, additionalCondition) => {
 		const conditions = [];
@@ -702,25 +914,38 @@ function createCrudRouter(config) {
 		});
 	};
 	const procedures = {
+		meta: metaProcedure.output(metadataOutputSchema).query(async ({ ctx }) => {
+			await withGuard(ctx, "list");
+			const target = readCrudTarget(config);
+			if (!target) return {};
+			const provider = resolveCrudExtensions(ctx, config);
+			if (!provider?.getMetadata) return {};
+			return provider.getMetadata({ id: target.id });
+		}),
 		list: resolved.procedureFactory("list").input(resolvedListInputSchema).output(listOutputSchema).query(async ({ ctx, input }) => {
 			await withGuard(ctx, "list");
 			const doList = async (listInput$1) => {
-				const offset = (listInput$1.page - 1) * listInput$1.perPage;
-				const validatedFilters = listInput$1.filters?.filter((filter) => validateColumn(filter.id, filterableColumns));
+				const effectiveInput = await applyCrudExtensionFilters(ctx, config, table, idField, filterableColumns, listInput$1);
+				const offset = (effectiveInput.page - 1) * effectiveInput.perPage;
+				const validatedFilters = effectiveInput.filters?.filter((filter) => isCrudExtensionIdFilter(filter, idField) || validateColumn(filter.id, filterableColumns));
 				const where = buildWhere(ctx, "list", validatedFilters?.length ? filterColumns({
 					table,
 					filters: validatedFilters,
-					joinOperator: listInput$1.joinOperator,
-					resolveColumn: (columnId) => resolveColumnTarget({
-						table,
-						columnId: String(columnId),
-						allowedColumns: filterableColumns
-					})
+					joinOperator: effectiveInput.joinOperator,
+					resolveColumn: (columnId) => {
+						const id = String(columnId);
+						if (id === idField) return getTableColumn(table, idField);
+						return resolveColumnTarget({
+							table,
+							columnId: id,
+							allowedColumns: filterableColumns
+						});
+					}
 				}) : void 0);
 				let query = ctx.db.select().from(table).$dynamic();
 				if (where) query = query.where(where);
-				if (listInput$1.sort?.length) {
-					const sortField = listInput$1.sort[0];
+				if (effectiveInput.sort?.length) {
+					const sortField = effectiveInput.sort[0];
 					if (sortField && validateColumn(sortField.id, sortableColumns)) {
 						const column = resolveColumnTarget({
 							table,
@@ -730,16 +955,16 @@ function createCrudRouter(config) {
 						if (column) query = query.orderBy(sortField.desc ? (0, drizzle_orm.desc)(column) : (0, drizzle_orm.asc)(column));
 					}
 				}
-				const data = await query.limit(listInput$1.perPage).offset(offset);
+				const enrichedData = await enrichCrudRows(ctx, config, idField, await query.limit(effectiveInput.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 {
-					data,
+					data: enrichedData,
 					total: count,
-					page: listInput$1.page,
-					perPage: listInput$1.perPage,
-					pageCount: Math.ceil(count / listInput$1.perPage)
+					page: effectiveInput.page,
+					perPage: effectiveInput.perPage,
+					pageCount: Math.ceil(count / effectiveInput.perPage)
 				};
 			};
 			const listInput = input;
@@ -757,7 +982,9 @@ function createCrudRouter(config) {
 				const where = buildWhere(ctx, "get", (0, drizzle_orm.eq)(getIdColumn(), id$1));
 				const [item] = await ctx.db.select().from(table).where(where);
 				await withAuthorize(ctx, item, "get");
-				return item ?? null;
+				if (!item) return null;
+				const [enriched] = await enrichCrudRows(ctx, config, idField, [item]);
+				return enriched ?? null;
 			};
 			const id = typeof input === "string" ? input : input.id;
 			if (m.get) return m.get({
@@ -771,12 +998,15 @@ function createCrudRouter(config) {
 		create: resolved.procedureFactory("create").input(schema).output(entityOutputSchema).mutation(async ({ ctx, input }) => {
 			await withGuard(ctx, "create");
 			const doCreate = async (inputData) => {
+				const splitInput = splitCrudExtensionWriteInput(inputData, tableColumnNames);
+				assertCrudExtraValuesWritable(ctx, config, splitInput);
 				const injectData = resolved.getInject(ctx, "create");
 				const data = {
-					...inputData,
+					...splitInput.data,
 					...injectData
 				};
 				const [created] = await ctx.db.insert(table).values(data).returning();
+				await saveCrudExtraValues(ctx, config, created?.[idField], splitInput);
 				return created;
 			};
 			if (m.create) return m.create({
@@ -799,12 +1029,16 @@ function createCrudRouter(config) {
 				message: "Resource not found or access denied"
 			});
 			const doUpdate = async (updateData) => {
+				const splitUpdate = splitCrudExtensionWriteInput(updateData, tableColumnNames);
+				assertCrudExtraValuesWritable(ctx, config, splitUpdate);
 				const injectData = resolved.getInject(ctx, "update");
 				const data = {
-					...updateData,
+					...splitUpdate.data,
 					...injectData
 				};
-				const [updated] = await ctx.db.update(table).set(data).where(where).returning();
+				let updated = existing;
+				if (Object.keys(data).length > 0) [updated] = await ctx.db.update(table).set(data).where(where).returning();
+				await saveCrudExtraValues(ctx, config, input.id, splitUpdate);
 				return updated;
 			};
 			if (m.update) return m.update({
@@ -860,12 +1094,18 @@ function createCrudRouter(config) {
 			await withGuard(ctx, "updateMany");
 			const where = buildWhere(ctx, "updateMany", (0, drizzle_orm.inArray)(getIdColumn(), input.ids));
 			const doUpdateMany = async (updateData) => {
+				const splitUpdate = splitCrudExtensionWriteInput(updateData, tableColumnNames);
+				assertCrudExtraValuesWritable(ctx, config, splitUpdate);
 				const injectData = resolved.getInject(ctx, "update");
 				const data = {
-					...updateData,
+					...splitUpdate.data,
 					...injectData
 				};
-				return { updated: (await ctx.db.update(table).set(data).where(where).returning({ id: getIdColumn() })).length };
+				let updated = input.ids.map((id) => ({ [idField]: id }));
+				if (Object.keys(data).length > 0) updated = await ctx.db.update(table).set(data).where(where).returning({ [idField]: getIdColumn() });
+				else updated = await ctx.db.select({ [idField]: getIdColumn() }).from(table).where(where);
+				await Promise.all(updated.map((row) => saveCrudExtraValues(ctx, config, row[idField], splitUpdate)));
+				return { updated: updated.length };
 			};
 			if (m.updateMany) return m.updateMany({
 				ctx,
@@ -878,7 +1118,9 @@ function createCrudRouter(config) {
 		upsert: resolved.procedureFactory("upsert").input(schema).output(upsertOutputSchema).mutation(async ({ ctx, input }) => {
 			await withGuard(ctx, "upsert");
 			const doUpsert = async (inputData) => {
-				const inputId = inputData[idField];
+				const splitInput = splitCrudExtensionWriteInput(inputData, tableColumnNames);
+				assertCrudExtraValuesWritable(ctx, config, splitInput);
+				const inputId = splitInput.data[idField];
 				let isNew = true;
 				let existing = null;
 				if (inputId) {
@@ -890,16 +1132,17 @@ function createCrudRouter(config) {
 				}
 				const injectData = resolved.getInject(ctx, isNew ? "create" : "update");
 				const data = {
-					...inputData,
+					...splitInput.data,
 					...injectData
 				};
 				const [result] = await ctx.db.insert(table).values(data).onConflictDoUpdate({
 					target: getIdColumn(),
 					set: {
-						...inputData,
+						...splitInput.data,
 						...resolved.getInject(ctx, "update")
 					}
 				}).returning();
+				await saveCrudExtraValues(ctx, config, result?.[idField] ?? inputId, splitInput);
 				return {
 					data: result,
 					isNew
@@ -915,22 +1158,32 @@ function createCrudRouter(config) {
 		export: resolved.procedureFactory("export").input(resolvedExportInputSchema).output(exportOutputSchema).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 effectiveInput = await applyCrudExtensionFilters(ctx, config, table, idField, filterableColumns, {
+					page: 1,
+					perPage: Math.min(Math.max(exportInput$1.limit ?? maxExportSize, 1), maxExportSize),
+					joinOperator: exportInput$1.joinOperator ?? "and",
+					...exportInput$1
+				});
+				const effectiveLimit = Math.min(Math.max(effectiveInput.limit ?? maxExportSize, 1), maxExportSize);
+				const validatedFilters = effectiveInput.filters?.filter((filter) => isCrudExtensionIdFilter(filter, idField) || validateColumn(filter.id, filterableColumns));
 				const where = buildWhere(ctx, "export", validatedFilters?.length ? filterColumns({
 					table,
 					filters: validatedFilters,
-					joinOperator: exportInput$1.joinOperator ?? "and",
-					resolveColumn: (columnId) => resolveColumnTarget({
-						table,
-						columnId: String(columnId),
-						allowedColumns: filterableColumns
-					})
+					joinOperator: effectiveInput.joinOperator ?? "and",
+					resolveColumn: (columnId) => {
+						const id = String(columnId);
+						if (id === idField) return getTableColumn(table, idField);
+						return resolveColumnTarget({
+							table,
+							columnId: id,
+							allowedColumns: filterableColumns
+						});
+					}
 				}) : 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 (effectiveInput.sort?.length) {
+					const sortField = effectiveInput.sort[0];
 					if (sortField && validateColumn(sortField.id, sortableColumns)) {
 						const column = resolveColumnTarget({
 							table,
@@ -940,14 +1193,14 @@ function createCrudRouter(config) {
 						if (column) query = query.orderBy(sortField.desc ? (0, drizzle_orm.desc)(column) : (0, drizzle_orm.asc)(column));
 					}
 				}
-				const data = await query.limit(effectiveLimit);
+				const enrichedData = await enrichCrudRows(ctx, config, idField, await query.limit(effectiveLimit));
 				let countQuery = ctx.db.select({ count: drizzle_orm.sql`count(*)::int` }).from(table).$dynamic();
 				if (where) countQuery = countQuery.where(where);
 				const total = (await countQuery)[0]?.count ?? 0;
 				return {
-					data,
+					data: enrichedData,
 					total,
-					hasMore: total > data.length
+					hasMore: total > enrichedData.length
 				};
 			};
 			const exportInput = input;
@@ -961,12 +1214,15 @@ function createCrudRouter(config) {
 		createMany: resolved.procedureFactory("createMany").input(zod.z.array(schema).min(1).max(maxBatchSize)).output(createManyOutputSchema).mutation(async ({ ctx, input }) => {
 			await withGuard(ctx, "createMany");
 			const doCreateMany = async (items) => {
+				const splitItems = items.map((item) => splitCrudExtensionWriteInput(item, tableColumnNames));
+				assertCrudExtraValuesWritableForRows(ctx, config, splitItems);
 				const injectData = resolved.getInject(ctx, "create");
-				const values = items.map((item) => ({
-					...item,
+				const values = splitItems.map(({ data }) => ({
+					...data,
 					...injectData
 				}));
 				const created = await ctx.db.insert(table).values(values).onConflictDoNothing().returning();
+				await saveCrudExtraValuesForRows(ctx, config, idField, created, splitItems);
 				return {
 					created,
 					count: created.length
@@ -987,8 +1243,10 @@ function createCrudRouter(config) {
 				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 {
+					if (result.success) {
+						const splitRow = splitCrudExtensionWriteInput(result.data, tableColumnNames);
+						validRows.push(splitRow);
+					} else {
 						const errors = result.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`);
 						failed.push({
 							row: i,
@@ -1008,26 +1266,30 @@ function createCrudRouter(config) {
 					skipped: 0,
 					failed
 				};
+				assertCrudExtraValuesWritableForRows(ctx, config, validRows);
 				const injectData = resolved.getInject(ctx, "create");
 				const values = validRows.map((row) => ({
-					...row,
+					...row.data,
 					...injectData
 				}));
 				let insertedCount = 0;
 				let updatedCount = 0;
 				if (importData$1.onConflict === "upsert") {
 					const existingCount = (await ctx.db.select({ id: getIdColumn() }).from(table).where((0, drizzle_orm.inArray)(getIdColumn(), values.map((v) => v[idField]).filter(Boolean)))).length;
-					const updateFields = Object.keys(validRows[0]);
+					const updateFields = Object.keys(validRows[0].data);
 					const setClause = { ...resolved.getInject(ctx, "update") };
 					for (const key of updateFields) setClause[key] = drizzle_orm.sql.raw(`excluded."${key}"`);
 					const results = await ctx.db.insert(table).values(values).onConflictDoUpdate({
 						target: getIdColumn(),
 						set: setClause
 					}).returning({ id: getIdColumn() });
+					await saveCrudExtraValuesForRows(ctx, config, idField, results.map((result) => ({ [idField]: result.id })), validRows);
 					updatedCount = Math.min(existingCount, results.length);
 					insertedCount = results.length - updatedCount;
 				} else {
-					insertedCount = (await ctx.db.insert(table).values(values).onConflictDoNothing().returning({ id: getIdColumn() })).length;
+					const inserted = await ctx.db.insert(table).values(values).onConflictDoNothing().returning({ id: getIdColumn() });
+					await saveCrudExtraValuesForRows(ctx, config, idField, inserted.map((result) => ({ [idField]: result.id })), validRows);
+					insertedCount = inserted.length;
 					updatedCount = 0;
 				}
 				const skipped = validRows.length - insertedCount - updatedCount;