@wordrhyme/auto-crud-server 0.4.0 → 0.6.1

package/dist/index.d.cts

@@ -1,6 +1,5 @@
-import * as _trpc_server5 from "@trpc/server";
+import * as _trpc_server2 from "@trpc/server";
 import { PostgresJsDatabase } from "drizzle-orm/postgres-js";
-import * as node_modules__trpc_server_dist_unstable_core_do_not_import_d_CjQPvBRI_mjs0 from "node_modules/@trpc/server/dist/unstable-core-do-not-import.d-CjQPvBRI.mjs";
 import { SQL } from "drizzle-orm";
 import { PgTable } from "drizzle-orm/pg-core";
 import { z } from "zod";
@@ -13,16 +12,16 @@ import { z } from "zod";
 interface Context {
   db: PostgresJsDatabase<Record<string, never>>;
 }
-declare const router: _trpc_server5.TRPCRouterBuilder<{
+declare const router: _trpc_server2.TRPCRouterBuilder<{
   ctx: Context;
   meta: object;
-  errorShape: _trpc_server5.TRPCDefaultErrorShape;
+  errorShape: _trpc_server2.TRPCDefaultErrorShape;
   transformer: true;
 }>;
-declare const publicProcedure: _trpc_server5.TRPCProcedureBuilder<Context, object, object, _trpc_server5.TRPCUnsetMarker, _trpc_server5.TRPCUnsetMarker, _trpc_server5.TRPCUnsetMarker, _trpc_server5.TRPCUnsetMarker, false>;
+declare const publicProcedure: _trpc_server2.TRPCProcedureBuilder<Context, object, object, _trpc_server2.TRPCUnsetMarker, _trpc_server2.TRPCUnsetMarker, _trpc_server2.TRPCUnsetMarker, _trpc_server2.TRPCUnsetMarker, false>;
 //#endregion
 //#region src/types/config.d.ts
-type CrudOperation = "list" | "get" | "create" | "update" | "delete" | "deleteMany" | "updateMany";
+type CrudOperation = "list" | "get" | "create" | "update" | "delete" | "deleteMany" | "updateMany" | "upsert";
 type WriteOperation = "create" | "update";
 type AnyProcedure = any;
 interface SoftDeleteConfig {
@@ -71,100 +70,136 @@ interface ListResult<TSelect> {
   perPage: number;
   pageCount: number;
 }
+interface ListMiddlewareParams<TContext, TSelect> {
+  ctx: TContext;
+  input: ListInput;
+  next: (input?: ListInput) => Promise<ListResult<TSelect>>;
+}
+interface GetMiddlewareParams<TContext, TSelect> {
+  ctx: TContext;
+  id: string;
+  next: () => Promise<TSelect | null>;
+}
+interface CreateMiddlewareParams<TContext, TSelect, TInsert> {
+  ctx: TContext;
+  input: TInsert;
+  next: (input?: TInsert) => Promise<TSelect>;
+}
+interface UpdateMiddlewareParams<TContext, TSelect, TUpdate> {
+  ctx: TContext;
+  id: string;
+  data: TUpdate;
+  existing: TSelect;
+  next: (data?: TUpdate) => Promise<TSelect>;
+}
+interface DeleteMiddlewareParams<TContext, TSelect> {
+  ctx: TContext;
+  id: string;
+  existing: TSelect;
+  next: () => Promise<TSelect>;
+}
+interface DeleteManyMiddlewareParams<TContext> {
+  ctx: TContext;
+  ids: string[];
+  next: () => Promise<{
+    deleted: number;
+  }>;
+}
+interface UpdateManyMiddlewareParams<TContext, TUpdate> {
+  ctx: TContext;
+  ids: string[];
+  data: TUpdate;
+  next: (data?: TUpdate) => Promise<{
+    updated: number;
+  }>;
+}
+interface UpsertMiddlewareParams<TContext, TSelect, TInsert> {
+  ctx: TContext;
+  input: TInsert;
+  next: (input?: TInsert) => Promise<{
+    data: TSelect;
+    isNew: boolean;
+  }>;
+}
 /**
- * CRUD 生命周期钩子
+ * 操作包装器 - 类似 tRPC middleware 的 next 模式
+ *
+ * 功能：
+ * - 修改输入数据（传参给 next）
+ * - 修改返回值（处理 next 的结果）
+ * - 执行副作用（日志、通知、审计）
+ * - 条件拦截（不调用 next 直接返回/抛错）
+ * - 包装事务（try/catch 包裹 next）
+ *
+ * @typeParam TContext - 上下文类型
+ * @typeParam TSelect - 查询返回类型（从 selectSchema 推断）
+ * @typeParam TInsert - 创建输入类型（从 insertSchema 推断）
+ * @typeParam TUpdate - 更新输入类型（从 updateSchema 推断）
  *
  * @example
- * hooks: {
- *   beforeCreate: async (ctx, data) => {
- *     // 修改数据
- *     return { ...data, slug: slugify(data.title) };
- *   },
- *   afterCreate: async (ctx, created) => {
- *     // 发送通知
- *     await sendNotification(created);
+ * // 修改输入 + 执行副作用
+ * middleware: {
+ *   create: async ({ ctx, input, next }) => {
+ *     const data = { ...input, slug: slugify(input.title) };
+ *     const result = await next(data);
+ *     await sendNotification(result);
+ *     return result;
  *   },
  * }
  */
-interface CrudHooks<TContext = unknown> {
+interface CrudMiddleware<TContext = unknown, TSelect = unknown, TInsert = unknown, TUpdate = unknown> {
   /**
-   * 列表查询前
-   * 可修改查询参数
+   * 列表查询包装器
    */
-  beforeList?: (ctx: TContext, input: ListInput) => ListInput | void | Promise<ListInput | void>;
+  list?: (params: ListMiddlewareParams<TContext, TSelect>) => Promise<ListResult<TSelect>>;
   /**
-   * 列表查询后
-   * 可修改返回结果
+   * 单条查询包装器
    */
-  afterList?: <TSelect>(ctx: TContext, result: ListResult<TSelect>) => ListResult<TSelect> | void | Promise<ListResult<TSelect> | void>;
+  get?: (params: GetMiddlewareParams<TContext, TSelect>) => Promise<TSelect | null>;
   /**
-   * 单条查询前
+   * 创建包装器
    */
-  beforeGet?: (ctx: TContext, id: string) => void | Promise<void>;
+  create?: (params: CreateMiddlewareParams<TContext, TSelect, TInsert>) => Promise<TSelect>;
   /**
-   * 单条查询后
-   * 可修改返回结果
+   * 更新包装器
+   * existing: 更新前的记录
    */
-  afterGet?: <TSelect>(ctx: TContext, result: TSelect | null) => TSelect | null | void | Promise<TSelect | null | void>;
+  update?: (params: UpdateMiddlewareParams<TContext, TSelect, TUpdate>) => Promise<TSelect>;
   /**
-   * 创建前
-   * 可修改输入数据，返回新数据或抛出错误阻止创建
+   * 删除包装器
+   * existing: 删除前的记录
    */
-  beforeCreate?: <TInsert>(ctx: TContext, data: TInsert) => TInsert | void | Promise<TInsert | void>;
+  delete?: (params: DeleteMiddlewareParams<TContext, TSelect>) => Promise<TSelect>;
   /**
-   * 创建后
-   * 用于副作用（日志、通知、同步等）
+   * 批量删除包装器
    */
-  afterCreate?: <TSelect>(ctx: TContext, created: TSelect) => void | Promise<void>;
-  /**
-   * 更新前
-   * 可修改输入数据，existing 为更新前的记录
-   */
-  beforeUpdate?: <TUpdate, TSelect>(ctx: TContext, id: string, data: TUpdate, existing: TSelect) => TUpdate | void | Promise<TUpdate | void>;
-  /**
-   * 更新后
-   */
-  afterUpdate?: <TSelect>(ctx: TContext, updated: TSelect) => void | Promise<void>;
-  /**
-   * 删除前
-   * existing 为删除前的记录，可抛出错误阻止删除
-   */
-  beforeDelete?: <TSelect>(ctx: TContext, id: string, existing: TSelect) => void | Promise<void>;
-  /**
-   * 删除后
-   */
-  afterDelete?: <TSelect>(ctx: TContext, deleted: TSelect) => void | Promise<void>;
-  /**
-   * 批量删除前
-   */
-  beforeDeleteMany?: (ctx: TContext, ids: string[]) => void | Promise<void>;
-  /**
-   * 批量删除后
-   */
-  afterDeleteMany?: (ctx: TContext, result: {
+  deleteMany?: (params: DeleteManyMiddlewareParams<TContext>) => Promise<{
     deleted: number;
-  }) => void | Promise<void>;
+  }>;
   /**
-   * 批量更新前
-   * 可修改输入数据
+   * 批量更新包装器
    */
-  beforeUpdateMany?: <TUpdate>(ctx: TContext, ids: string[], data: TUpdate) => TUpdate | void | Promise<TUpdate | void>;
+  updateMany?: (params: UpdateManyMiddlewareParams<TContext, TUpdate>) => Promise<{
+    updated: number;
+  }>;
   /**
-   * 批量更新后
+   * Upsert 包装器
+   * isNew: 是否为新建（冲突检测后）
    */
-  afterUpdateMany?: (ctx: TContext, result: {
-    updated: number;
-  }) => void | Promise<void>;
+  upsert?: (params: UpsertMiddlewareParams<TContext, TSelect, TInsert>) => Promise<{
+    data: TSelect;
+    isNew: boolean;
+  }>;
 }
-interface CrudRouterConfigBase<TContext = unknown> {
+interface CrudRouterConfigBase<TContext = unknown, TSelect = unknown, TInsert = unknown, TUpdate = unknown> {
   /** Drizzle 表定义 */
   table: PgTable;
   /** 查询返回 Schema */
-  selectSchema?: z.ZodType;
+  selectSchema?: z.ZodType<TSelect>;
   /** 创建输入 Schema */
-  insertSchema: z.ZodType;
+  insertSchema: z.ZodType<TInsert>;
   /** 更新输入 Schema */
-  updateSchema: z.ZodType;
+  updateSchema: z.ZodType<TUpdate>;
   /** ID 字段名，默认 "id" */
   idField?: string;
   /** 可过滤的列白名单 */
@@ -192,22 +227,36 @@ interface CrudRouterConfigBase<TContext = unknown> {
    */
   softDelete?: SoftDeleteOption;
   /**
-   * 生命周期钩子
-   * 在 CRUD 操作前后注入自定义逻辑
+   * 操作中间件
+   * 类似 tRPC middleware 的 next 模式，完全控制操作流程
    *
    * @example
-   * hooks: {
-   *   beforeCreate: async (ctx, data) => {
-   *     return { ...data, slug: slugify(data.title) };
-   *   },
-   *   afterCreate: async (ctx, created) => {
-   *     await sendNotification(created);
+   * // 完整控制
+   * middleware: {
+   *   create: async ({ ctx, input, next }) => {
+   *     const data = { ...input, slug: slugify(input.title) };
+   *     const result = await next(data);
+   *     await sendNotification(result);
+   *     return result;
    *   },
    * }
+   *
+   * @example
+   * // 使用工具函数简化
+   * import { afterMiddleware, beforeMiddleware } from "@wordrhyme/auto-crud-server";
+   *
+   * middleware: {
+   *   create: afterMiddleware(async (ctx, result) => {
+   *     await sendEmail(result);
+   *   }),
+   *   update: beforeMiddleware(async (ctx, data) => {
+   *     return { ...data, updatedAt: new Date() };
+   *   }),
+   * }
    */
-  hooks?: CrudHooks<TContext>;
+  middleware?: CrudMiddleware<TContext, TSelect, TInsert, TUpdate>;
 }
-interface DeclarativeConfig<TContext = unknown> extends CrudRouterConfigBase<TContext> {
+interface DeclarativeConfig<TContext = unknown, TSelect = unknown, TInsert = unknown, TUpdate = unknown> extends CrudRouterConfigBase<TContext, TSelect, TInsert, TUpdate> {
   mode?: "declarative";
   /**
    * 基础 procedure（认证）
@@ -245,9 +294,9 @@ interface DeclarativeConfig<TContext = unknown> extends CrudRouterConfigBase<TCo
    * @example
    * authorize: (ctx, resource, op) => resource.ownerId === ctx.user.id
    */
-  authorize?: (ctx: TContext, resource: Record<string, unknown>, operation: CrudOperation) => boolean | Promise<boolean>;
+  authorize?: (ctx: TContext, resource: TSelect, operation: CrudOperation) => boolean | Promise<boolean>;
 }
-interface FactoryConfig<TContext = unknown> extends CrudRouterConfigBase<TContext> {
+interface FactoryConfig<TContext = unknown, TSelect = unknown, TInsert = unknown, TUpdate = unknown> extends CrudRouterConfigBase<TContext, TSelect, TInsert, TUpdate> {
   mode: "factory";
   /**
    * Procedure 工厂函数
@@ -266,7 +315,7 @@ interface FactoryConfig<TContext = unknown> extends CrudRouterConfigBase<TContex
    */
   inject?: (ctx: TContext, operation: WriteOperation) => Record<string, unknown>;
 }
-interface ProceduresConfig<TContext = unknown> extends CrudRouterConfigBase<TContext> {
+interface ProceduresConfig<TContext = unknown, TSelect = unknown, TInsert = unknown, TUpdate = unknown> extends CrudRouterConfigBase<TContext, TSelect, TInsert, TUpdate> {
   mode: "procedures";
   /**
    * 按操作指定不同的 procedure
@@ -290,49 +339,95 @@ interface ProceduresConfig<TContext = unknown> extends CrudRouterConfigBase<TCon
    */
   inject?: (ctx: TContext, operation: WriteOperation) => Record<string, unknown>;
 }
-type CrudRouterConfig<TContext = unknown> = DeclarativeConfig<TContext> | FactoryConfig<TContext> | ProceduresConfig<TContext>;
+type CrudRouterConfig<TContext = unknown, TSelect = unknown, TInsert = unknown, TUpdate = unknown> = DeclarativeConfig<TContext, TSelect, TInsert, TUpdate> | FactoryConfig<TContext, TSelect, TInsert, TUpdate> | ProceduresConfig<TContext, TSelect, TInsert, TUpdate>;
+interface CrudProcedures<TSelect, TInsert, TUpdate> {
+  list: AnyProcedure;
+  get: AnyProcedure;
+  create: AnyProcedure;
+  update: AnyProcedure;
+  delete: AnyProcedure;
+  deleteMany: AnyProcedure;
+  updateMany: AnyProcedure;
+  upsert: AnyProcedure;
+}
 //#endregion
 //#region src/routers/_factory.d.ts
-declare function createCrudRouter<TContext = unknown>(config: CrudRouterConfig<TContext>): node_modules__trpc_server_dist_unstable_core_do_not_import_d_CjQPvBRI_mjs0.Router<{
-  ctx: Context;
-  meta: object;
-  errorShape: _trpc_server5.TRPCDefaultErrorShape;
-  transformer: true;
-}, _trpc_server5.TRPCDecorateCreateRouterOptions<{
-  list: any;
-  getById: any;
-  create: any;
-  update: any;
-  delete: any;
-  deleteMany: any;
-  updateMany: any;
-}>> & _trpc_server5.TRPCDecorateCreateRouterOptions<{
-  list: any;
-  getById: any;
-  create: any;
-  update: any;
-  delete: any;
-  deleteMany: any;
-  updateMany: any;
-}> & {
-  procedures: {
-    list: any;
-    getById: any;
-    create: any;
-    update: any;
-    delete: any;
-    deleteMany: any;
-    updateMany: any;
-  };
+/**
+ * 创建 CRUD Router
+ *
+ * @typeParam TContext - 上下文类型（包含 db）
+ * @typeParam TSelect - 查询返回类型（从 selectSchema 或 insertSchema 推断）
+ * @typeParam TInsert - 创建输入类型（从 insertSchema 推断）
+ * @typeParam TUpdate - 更新输入类型（从 updateSchema 推断）
+ */
+declare function createCrudRouter<TContext = unknown, TSelect = unknown, TInsert = unknown, TUpdate = unknown>(config: CrudRouterConfig<TContext, TSelect, TInsert, TUpdate>): ReturnType<typeof router> & {
+  procedures: CrudProcedures<TSelect, TInsert, TUpdate>;
+};
+//#endregion
+//#region src/lib/middleware-helpers.d.ts
+/**
+ * Middleware 便捷工具函数
+ * 简化常见场景的 middleware 创建
+ */
+/**
+ * 创建 after-only 的 middleware（最常见场景）
+ * 在操作完成后执行副作用，不修改返回值
+ *
+ * @example
+ * middleware: {
+ *   create: afterMiddleware(async (ctx, result) => {
+ *     await sendEmail(result);
+ *     await logAudit(ctx.user, 'create', result);
+ *   }),
+ * }
+ */
+declare function afterMiddleware<TContext, TResult>(fn: (ctx: TContext, result: TResult) => void | Promise<void>): (params: {
+  ctx: TContext;
+  next: () => Promise<TResult>;
+  [key: string]: any;
+}) => Promise<TResult>;
+/**
+ * 创建 before-only 的 middleware
+ * 在操作执行前修改输入数据
+ *
+ * @example
+ * middleware: {
+ *   create: beforeMiddleware(async (ctx, input) => {
+ *     return { ...input, slug: slugify(input.title), createdBy: ctx.user.id };
+ *   }),
+ * }
+ */
+declare function beforeMiddleware<TContext, TInput>(fn: (ctx: TContext, input: TInput) => TInput | Promise<TInput>): <TResult>(params: {
+  ctx: TContext;
+  input: TInput;
+  next: (input?: TInput) => Promise<TResult>;
+  [key: string]: any;
+}) => Promise<TResult>;
+type AnyMiddlewareParams<TContext> = {
+  ctx: TContext;
+  next: (...args: any[]) => Promise<any>;
+  [key: string]: any;
 };
+/**
+ * 组合多个 middleware 为一个
+ *
+ * @example
+ * middleware: {
+ *   create: composeMiddleware(
+ *     beforeMiddleware((ctx, input) => ({ ...input, slug: slugify(input.title) })),
+ *     afterMiddleware((ctx, result) => sendEmail(result)),
+ *   ),
+ * }
+ */
+declare function composeMiddleware<TContext, TResult>(...middlewares: Array<(params: AnyMiddlewareParams<TContext>) => Promise<any>>): (params: AnyMiddlewareParams<TContext>) => Promise<TResult>;
 //#endregion
 //#region src/routers/index.d.ts
-declare const appRouter: _trpc_server5.TRPCBuiltRouter<{
+declare const appRouter: _trpc_server2.TRPCBuiltRouter<{
   ctx: Context;
   meta: object;
-  errorShape: _trpc_server5.TRPCDefaultErrorShape;
+  errorShape: _trpc_server2.TRPCDefaultErrorShape;
   transformer: true;
-}, _trpc_server5.TRPCDecorateCreateRouterOptions<{}>>;
+}, _trpc_server2.TRPCDecorateCreateRouterOptions<{}>>;
 type AppRouter = typeof appRouter;
 //#endregion
-export { type AnyProcedure, type AppRouter, type CrudHooks, type CrudOperation, type CrudRouterConfig, type DeclarativeConfig, type FactoryConfig, type ListInput, type ListResult, type ProceduresConfig, type SoftDeleteConfig, type SoftDeleteOption, type WriteOperation, appRouter, createCrudRouter, publicProcedure, router };
+export { type AnyProcedure, type AppRouter, type CreateMiddlewareParams, type CrudMiddleware, type CrudOperation, type CrudProcedures, type CrudRouterConfig, type CrudRouterConfigBase, type DeclarativeConfig, type DeleteManyMiddlewareParams, type DeleteMiddlewareParams, type FactoryConfig, type GetMiddlewareParams, type ListInput, type ListMiddlewareParams, type ListResult, type ProceduresConfig, type SoftDeleteConfig, type SoftDeleteOption, type UpdateManyMiddlewareParams, type UpdateMiddlewareParams, type UpsertMiddlewareParams, type WriteOperation, afterMiddleware, appRouter, beforeMiddleware, composeMiddleware, createCrudRouter, publicProcedure, router };