@ai0x0/utils 0.0.14 → 0.0.16

package/SKILL.md

@@ -0,0 +1,336 @@
+---
+name: ai0x0-utils-backend
+description: Scaffold Next.js App Router CRUD endpoints and drizzle-orm(pg) tables with `@ai0x0/utils`. Use when a project needs standard list/get/create/update/delete routes backed by drizzle-orm + zod + next-rest-framework, auto-injected base fields (id / creatorId / createdAt…), paginated list queries with joins, or ready-to-use select/insert/update Zod schemas. Pair with the `create-next-rest-framework-api` skill — this skill replaces hand-written `routeOperation(...).input(...).outputs(...).handler(...)` chains with a declarative factory API exposed inside `next-rest-framework`'s `route({...})`.
+---
+
+# @ai0x0/utils Backend
+
+Declarative CRUD factory on top of `next-rest-framework` v6, `drizzle-orm/pg-core`, `drizzle-zod`, and `zod` v4. Each factory returns a `RouteOperationDefinition<Method>` so it plugs directly into `route({ … })` from next-rest-framework.
+
+## Workflow
+
+1. Create a shared options module (once per project) that pre-binds `{ db, getSession }` to every operation factory (see "Project Setup" below). Route files never import `db`/`getSession` directly.
+2. For each domain entity, place a `table.ts` next to an `index.ts`:
+   - `table.ts` — call `createTableSchema({ name, columns })` and re-export `table` only.
+   - `index.ts` — compose the zod schemas (`insertXxxSchema`, `selectXxxSchema`, `updateXxxSchema`, `queryXxxSchema`, `queryListXxxSchema`, `queryListSelectXxxSchema`). Extend with `.merge(z.object(...))` when the business exposes non-column fields (tags, computed columns).
+3. Author the CRUD `route.ts` by wrapping the pre-bound operations inside next-rest-framework's `route({...})`. Name each operation key descriptively — it is the OpenAPI `operationId`.
+4. Drop down to raw `routeOperation(...)` (via the `create-next-rest-framework-api` skill) when the endpoint is non-CRUD (auth, webhooks, streaming, multi-status) or needs custom `TypedNextResponse` unions.
+5. Reuse action-level helpers (`createGetAction`, `createGetListAction`, etc.) inside server actions, cron jobs, queue consumers, or the raw-`routeOperation` handlers — same API, no request wrapping.
+
+## Project Setup
+
+Create three files once and reuse everywhere:
+
+```ts
+// app/(backend)/db/schemas/_helper.ts — re-export + lock import path
+export {
+  createTableSchema,
+  queryListSchema,
+  listBodySchema,
+} from "@ai0x0/utils/lib/backend/schemas";
+```
+
+```ts
+// app/(backend)/utils/actions/_helper.ts — action-level helpers
+export {
+  createDeleteAction,
+  createGetAction,
+  createGetListAction,
+  createPostAction,
+  createPutAction,
+} from "@ai0x0/utils/lib/backend/actions";
+```
+
+```ts
+// app/(backend)/utils/route-operation/index.ts — pre-bind db + getSession
+import {
+  createGetOperation,
+  createPutOperation,
+  createPostOperation,
+  createDeleteOperation,
+  createGetListOperation,
+} from "@ai0x0/utils/lib/backend";
+import { db } from "@backend/db";
+import getSession from "@backend/utils/get-session";
+
+export const postOperation = createPostOperation({ db, getSession });
+export const deleteOperation = createDeleteOperation({ db, getSession });
+export const putOperation = createPutOperation({ db, getSession });
+export const getOperation = createGetOperation({ db, getSession });
+export const getListOperation = createGetListOperation({ db, getSession });
+```
+
+`getSession(req)` **must** return `{ userId?: string } | undefined` (a Promise is fine). Throwing rejects the request; returning `undefined` disables ownership checks for that call.
+
+## Factory Catalog
+
+| Export              | Purpose                    | Required options                     | Notable optional options                                                                    |
+| ------------------- | -------------------------- | ------------------------------------ | ------------------------------------------------------------------------------------------- |
+| `createTableSchema` | pg `Table` + 5 zod schemas | `name`, `columns`                    | `refineSchema`, `extraConfig`                                                               |
+| `getOperation`      | GET one by filters         | `table`, `bodySchema`, `querySchema` | `setParams`, `relations`, `jsonArrayFields`, `byCreator`, `onSuccess`, `onError`, `summary` |
+| `getListOperation`  | GET paginated list         | `table`, `bodySchema`, `querySchema` | `setParams`, `relations`, `jsonArrayFields`, `onSuccess`, `onError`, `summary`              |
+| `postOperation`     | POST create                | `table`, `bodySchema`                | `outputBodySchema`, `setBody`, `onSuccess`, `onError`, `summary`                            |
+| `putOperation`      | PUT update                 | `table`, `bodySchema`                | `outputBodySchema`, `setBody`, `byCreator`, `onSuccess`, `onError`, `summary`               |
+| `deleteOperation`   | DELETE                     | `table`                              | `byCreator`, `onSuccess`, `onError`, `summary`                                              |
+
+## Canonical Examples
+
+### 1. Table + schemas (`table.ts` + `index.ts`)
+
+```ts
+// app/(backend)/db/schemas/agent/table.ts
+import { jsonb, text } from "drizzle-orm/pg-core";
+import { createTableSchema } from "@backend/db/schemas/_helper";
+
+export const agentColumns = {
+  name: text("name"),
+  modelId: text("model_id"),
+  tags: jsonb("tags"),
+  mcpIds: jsonb("mcp_ids"),
+};
+
+export const { table: agents } = createTableSchema({
+  name: "agents",
+  columns: agentColumns,
+});
+```
+
+```ts
+// app/(backend)/db/schemas/agent/index.ts
+import { createInsertSchema, createSelectSchema } from "drizzle-zod";
+import { z } from "zod";
+import { queryListSchema } from "@backend/db/schemas";
+import { agents } from "./table";
+
+export { agents, agentColumns } from "./table";
+
+export const insertAgentSchema = createInsertSchema(agents).merge(
+  z.object({
+    mcpIds: z.array(z.string()).optional(),
+    tags: z.array(z.string()).optional(),
+  }),
+);
+export const selectAgentSchema = createSelectSchema(agents).merge(
+  z.object({
+    mcpIds: z.array(z.string()).optional(),
+    tags: z.array(z.string()).optional(),
+  }),
+);
+export const updateAgentSchema = insertAgentSchema.required({ id: true });
+export const queryAgentSchema = insertAgentSchema.partial();
+export const queryListAgentSchema = queryListSchema(
+  selectAgentSchema.partial().merge(
+    z.object({ tags: z.string().optional() }), // 列表里 jsonArray 以逗号分隔字符串传入
+  ),
+);
+export const queryListSelectAgentSchema = selectAgentSchema;
+```
+
+Note the two-layer shape: `queryListSchema(...)` input is the **partial of the select schema** (optionally merged with extra querystring-only fields); `bodySchema` in `getListOperation` stays as the full select schema (`queryListSelectAgentSchema`).
+
+### 2. Detail CRUD route
+
+```ts
+// app/(backend)/api/agent/route.ts
+import { route } from "next-rest-framework";
+import {
+  agents,
+  insertAgentSchema,
+  queryAgentSchema,
+  selectAgentSchema,
+  updateAgentSchema,
+} from "@backend/db/schemas";
+import {
+  deleteOperation,
+  getOperation,
+  postOperation,
+  putOperation,
+} from "@backend/utils/route-operation";
+import getSession from "@backend/utils/get-session";
+import { seedAgentData } from "@backend/utils/actions";
+
+export const { POST, GET, DELETE, PUT } = route({
+  getAgent: getOperation({
+    querySchema: queryAgentSchema,
+    bodySchema: selectAgentSchema,
+    table: agents,
+    summary: "助手详情",
+    setParams: async (req) => {
+      const { userId } = (await getSession(req)) || {};
+      await seedAgentData(userId as string);
+      return {};
+    },
+  }),
+  postAgent: postOperation({
+    bodySchema: insertAgentSchema,
+    table: agents,
+    summary: "添加助手",
+    setBody: async () => ({ tags: ["my"] }),
+  }),
+  putAgent: putOperation({
+    bodySchema: updateAgentSchema,
+    table: agents,
+    summary: "编辑助手",
+  }),
+  deleteAgent: deleteOperation({
+    table: agents,
+    summary: "删除助手",
+  }),
+});
+```
+
+### 3. List route with relations + `onSuccess` tree building
+
+```ts
+// app/(backend)/api/channel/list/route.ts
+import { route } from "next-rest-framework";
+import { eq, sql } from "drizzle-orm";
+import {
+  channels,
+  models,
+  queryListChannelSchema,
+  queryListSelectChannelSchema,
+} from "@backend/db/schemas";
+import { getListOperation } from "@backend/utils/route-operation";
+import getSession from "@backend/utils/get-session";
+import { seedChannelData } from "@backend/utils/actions/channel";
+
+export const { GET } = route({
+  getChannelList: getListOperation({
+    querySchema: queryListChannelSchema,
+    bodySchema: queryListSelectChannelSchema,
+    table: channels,
+    summary: "获取渠道列表",
+    relations: [
+      {
+        table: models,
+        sql: eq(models.channelId, channels.id),
+        select: {
+          models: sql`(
+            SELECT array_agg(DISTINCT jsonb_strip_nulls(to_jsonb(models.*)))
+            FROM ${models}
+            WHERE ${models.channelId} = ${channels.id}
+          )`,
+        },
+      },
+    ],
+    setParams: async (req) => {
+      const { userId } = (await getSession(req)) || {};
+      await seedChannelData(userId as string);
+      return {};
+    },
+    onSuccess: async (result) => {
+      // 内部字段过滤 / 映射 / 树化都写在这里
+      return result;
+    },
+  }),
+});
+```
+
+For list routes that consume `jsonb` arrays as comma-separated querystring values, add `jsonArrayFields: ["tags"]`.
+
+### 4. Escape hatch — drop to raw `routeOperation` but reuse actions
+
+When the endpoint returns multiple status shapes (e.g. 200 success + 401 unauthorized), do **not** use the CRUD factories. Call `routeOperation` directly and reuse the action helpers for the database side:
+
+```ts
+// app/(backend)/api/user/me/route.ts
+import { TypedNextResponse, route, routeOperation } from "next-rest-framework";
+import { eq } from "drizzle-orm";
+import { z } from "zod";
+import { db } from "@backend/db";
+import { members, selectUserSchema, teams, users } from "@backend/db/schemas";
+import { createGetAction } from "@backend/utils/actions";
+import getSession from "@backend/utils/get-session";
+
+export const { GET } = route({
+  getUserMe: routeOperation({
+    method: "GET",
+    openApiOperation: { tags: ["users"], summary: "我的信息" },
+  })
+    .outputs([
+      { status: 200, contentType: "application/json", body: selectUserSchema },
+      {
+        status: 401,
+        contentType: "application/json",
+        body: z.object({ message: z.string() }),
+      },
+    ])
+    .handler(async (req) => {
+      const { userId } = (await getSession(req)) || {};
+      const user = await createGetAction({
+        db,
+        table: users,
+        bodySchema: selectUserSchema,
+        relations: [
+          { table: members, sql: eq(members.userId, users.id) },
+          {
+            groupBy: true,
+            table: teams,
+            select: { team: teams },
+            sql: eq(teams.id, members.teamId),
+          },
+        ],
+      })({ id: userId });
+      if (!user) {
+        return TypedNextResponse.json(
+          { message: "用户不存在" },
+          { status: 401 },
+        );
+      }
+      return TypedNextResponse.json(user, { status: 200 });
+    }),
+});
+```
+
+## Built-in Conventions
+
+- **Base fields** auto-added by `createTableSchema`: `id` (uuid, pk, default random) / `creatorId` / `editorId` / `accessedAt` / `createdAt` / `updatedAt`.
+- **Ownership check**: with `byCreator: true` (default on PUT/DELETE/GET), PUT/DELETE pre-fetch the row filtered by `creatorId = session.userId` and throw `"未找到…对象，或没有权限"` if missing. Set `byCreator: false` to skip (e.g. admin endpoints).
+- **Auto injection**: POST writes `creatorId = session.userId`; PUT writes `editorId = session.userId`; GET/GET_LIST append `creatorId = session.userId` to the filter when `byCreator` is on.
+- **Date coercion**: any body field ending in `At` is passed through `dayjs(value).toDate()` before write — accept ISO strings from clients.
+- **List filtering** (all querystring values are strings):
+  - `key=a,b,c` → `IN (...)` when key ends with `Id`; otherwise `OR ILIKE %a% OR ILIKE %b%`
+  - `key=foo` where key ends with `Id` → `eq`; otherwise `ILIKE %foo%`
+  - `${anything}AtFrom` / `${anything}AtTo` → `gte` / `lte` against the matching `${anything}At` column
+  - `jsonArrayFields: ["tags"]` → `EXISTS (SELECT 1 FROM jsonb_array_elements_text(col) t WHERE t LIKE %v%)`
+- **Pagination / sort**: `current` (default `"1"`), `pageSize` (default `"10"`), `orderBy` (default `createdAt`), `orderDir` (`asc|desc`, default `desc`).
+- **Relations**: `relations: [{ table, sql, select, groupBy? }]` drives `leftJoin` + optional `groupBy(root.id, relation.id)`; `select` merges into the final `SELECT` projection and can contain raw `sql\`…\`` correlated sub-queries.
+
+## Guardrails
+
+- Always pass `insertXxxSchema` to POST, `updateXxxSchema` (has `.required({ id: true })`) to PUT, `selectXxxSchema` to GET body, `queryListSchema(selectXxxSchema.partial())` to GET_LIST query.
+- Query-string schemas stay `z.string()` — numbers / arrays from querystrings must stay strings and be parsed inside `onSuccess` or `setParams`.
+- Do not reuse `insertSchema` for PUT — missing `id` silently dispatches an update without a where clause.
+- `bodySchema` on list/get is the **response item** schema, not the query shape. Query shape goes in `querySchema`.
+- Do not inline `{ db, getSession }` into individual route files — always import the pre-bound `postOperation` / `getListOperation` / … from `@backend/utils/route-operation` so session/DB swaps are one-file changes.
+- `jsonb` columns declared with `jsonb(...)` carry no zod info — extend the matching insert/select schema with `.merge(z.object({ field: z.array(z.string()).optional() }))` to keep typing accurate.
+- Swallowing errors: an unhandled throw in a handler propagates to next-rest-framework as a 500. Provide `onError` for any operation exposed to untrusted clients.
+- For non-CRUD behavior (middleware chains, streaming, multipart, `TypedNextResponse` unions, RPC) stop using these factories and switch to the `create-next-rest-framework-api` skill.
+
+## Escape Hatches
+
+- Extra server-side filters — `setParams(req) => Promise<Record<string, unknown>>` on GET/GET_LIST; returned keys are merged into the filter.
+- Extra columns on write — `setBody(req) => Promise<Partial<infer<IB>>>` on POST/PUT; returned fields are merged into the body before validation runs against `bodySchema`.
+- Post-processing output — `onSuccess(data) => Promise<data>`; on GET_LIST the payload is `{ data, total }`.
+- Error rewriting — `onError(err) => Promise<Response | undefined>`. Return `undefined` to rethrow.
+
+## Imports
+
+```
+@ai0x0/utils/lib/backend                   // actions + route-operation + schemas (CJS, used by Next.js server bundle)
+@ai0x0/utils/lib/backend/actions
+@ai0x0/utils/lib/backend/route-operation
+@ai0x0/utils/lib/backend/schemas
+```
+
+ESM consumers can substitute `/es/backend/...` instead of `/lib/backend/...` when Next.js resolves the `exports` map that way; prefer `/lib/backend` in Next.js projects because the server bundle is CommonJS.
+
+## Done Criteria
+
+- Route files contain zero hand-written `{ db, getSession }` wiring; all operations come from `@backend/utils/route-operation`.
+- Each domain has a `table.ts` (columns + `createTableSchema`) and an `index.ts` (five zod schemas + re-exports).
+- Every list endpoint accepts `current / pageSize / orderBy / orderDir / *AtFrom / *AtTo` and — where applicable — `jsonArrayFields` is declared.
+- `byCreator` is explicitly set when the endpoint is admin-facing or otherwise crosses ownership boundaries.
+- Non-CRUD endpoints are implemented via raw `routeOperation` + action helpers, not by forcing a CRUD factory.
+- `next-rest-framework validate` / `generate` (from the partner skill) still pass — the factory values are plain `RouteOperationDefinition` and participate in OpenAPI generation.

package/es/__shims__/next-rest-framework.d.ts

@@ -0,0 +1,48 @@
+import type { NextRequest } from "next/server";
+import type { ZodType } from "zod";
+
+declare module "next-rest-framework" {
+  export interface RouteOperationDefinition<M extends string = string> {
+    _method: M;
+  }
+
+  interface RouteOperationBuilder<M extends string> {
+    input: (opts: {
+      body?: ZodType;
+      query?: ZodType;
+      contentType?: string;
+    }) => RouteOperationBuilder<M>;
+    outputs: (
+      opts: { body?: ZodType; status?: number; contentType?: string }[],
+    ) => RouteOperationBuilder<M>;
+    handler: (
+      fn: (req: NextRequest) => Promise<Response>,
+    ) => RouteOperationDefinition<M>;
+  }
+
+  export const routeOperation: <M extends string>(opts: {
+    method: M;
+    openApiOperation?: { summary?: string; tags?: string[] };
+  }) => RouteOperationBuilder<M>;
+
+  export const rpcOperation: () => {
+    outputs: (opts: { body?: ZodType; contentType?: string }[]) => {
+      handler: <T>(fn: () => Promise<T>) => () => Promise<T>;
+    };
+  };
+
+  export const TypedNextResponse: {
+    json: <T>(body: T, init?: { status?: number }) => Response;
+  };
+
+  export type TypedNextRequest<
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    M = string,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    C = string,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    B = unknown,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    Q = Record<string, string>,
+  > = NextRequest;
+}

package/es/backend/actions/create-delete-action.d.ts

@@ -1,7 +1,7 @@
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { BaseTable } from "../types";
 export declare function createDeleteAction<TTable extends BaseTable>({ table, db, }: {
-    db: NodePgDatabase<any>;
+    db: NodePgDatabase<Record<string, unknown>>;
     table: TTable;
 }): ({ id, creatorId }: {
     id: string;

package/es/backend/actions/create-get-action.d.ts

@@ -3,8 +3,8 @@ import { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { BaseTable, GetListRelations } from "../types";
 export declare function createGetAction<T extends ZodSchema, TTable extends BaseTable>({ bodySchema, db, jsonArrayFields, relations, table, }: {
     bodySchema: T;
-    db: NodePgDatabase<any>;
+    db: NodePgDatabase<Record<string, unknown>>;
     jsonArrayFields?: string[];
     relations?: GetListRelations;
     table: TTable;
-}): (params: Partial<z.infer<T>>) => Promise<T["_output"]>;
+}): (params: Partial<z.infer<T>> & Record<string, unknown>) => Promise<z.core.output<T> | undefined>;

package/es/backend/actions/create-get-action.js

@@ -40,7 +40,7 @@ export function createGetAction(_ref) {
               params: params,
               relations: relations,
               table: table
-            }), query = _getListQuery.query, countQuery = _getListQuery.countQuery; // 执行查询
+            }), query = _getListQuery.query, countQuery = _getListQuery.countQuery;
             _context.next = 5;
             return getListData({
               bodySchema: bodySchema,

package/es/backend/actions/create-get-list-action.d.ts

@@ -3,11 +3,11 @@ import { BaseTable, GetListRelations } from "../types";
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
 export declare function createGetListAction<T extends ZodSchema, TTable extends BaseTable>({ bodySchema, db, jsonArrayFields, relations, table, }: {
     bodySchema: T;
-    db: NodePgDatabase<any>;
+    db: NodePgDatabase<Record<string, unknown>>;
     jsonArrayFields?: string[];
     relations?: GetListRelations;
     table: TTable;
-}): (params: Partial<z.infer<T>>) => Promise<{
-    data: T["_output"][];
+}): (params: Partial<z.infer<T>> & Record<string, unknown>) => Promise<{
+    data: any;
     total: number;
 }>;

package/es/backend/actions/create-get-list-action.js

@@ -15,11 +15,11 @@ export function createGetListAction(_ref) {
     table = _ref.table;
   return /*#__PURE__*/function () {
     var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(params) {
-      var current, pageSize, other, fields, _i, _Object$keys, key, field, _getListQuery, query, countQuery;
+      var _ref3, current, pageSize, other, fields, _i, _Object$keys, key, field, _getListQuery, query, countQuery;
       return _regeneratorRuntime().wrap(function _callee$(_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
-            current = params.current, pageSize = params.pageSize, other = _objectWithoutProperties(params, _excluded);
+            _ref3 = params, current = _ref3.current, pageSize = _ref3.pageSize, other = _objectWithoutProperties(_ref3, _excluded);
             fields = {}; // eslint-disable-next-line @typescript-eslint/ban-ts-comment
             // @ts-ignore
             for (_i = 0, _Object$keys = Object.keys(bodySchema.shape); _i < _Object$keys.length; _i++) {
@@ -38,7 +38,7 @@ export function createGetListAction(_ref) {
               params: other,
               relations: relations,
               table: table
-            }), query = _getListQuery.query, countQuery = _getListQuery.countQuery; // 执行查询
+            }), query = _getListQuery.query, countQuery = _getListQuery.countQuery;
             return _context.abrupt("return", getListData({
               bodySchema: bodySchema,
               countQuery: countQuery,

package/es/backend/actions/create-post-action.d.ts

@@ -3,6 +3,6 @@ import { PgTable } from "drizzle-orm/pg-core";
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
 export declare function createPostAction<T extends ZodSchema, TTable extends PgTable>({ table, db, }: {
     bodySchema: T;
-    db: NodePgDatabase<any>;
+    db: NodePgDatabase<Record<string, unknown>>;
     table: TTable;
-}): (body: z.infer<T>) => Promise<T["_output"][]>;
+}): (body: z.infer<T>) => Promise<z.infer<T>[]>;

package/es/backend/actions/create-post-action.js

@@ -8,11 +8,17 @@ export function createPostAction(_ref) {
     db = _ref.db;
   return /*#__PURE__*/function () {
     var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(body) {
+      var values, result;
       return _regeneratorRuntime().wrap(function _callee$(_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
-            return _context.abrupt("return", db.insert(table).values(transformBody(body)).returning());
-          case 1:
+            values = transformBody(body);
+            _context.next = 3;
+            return db.insert(table).values(values).returning();
+          case 3:
+            result = _context.sent;
+            return _context.abrupt("return", result);
+          case 5:
           case "end":
             return _context.stop();
         }

package/es/backend/actions/create-put-action.d.ts

@@ -3,8 +3,8 @@ import { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { BaseTable } from "../types";
 export declare function createPutAction<T extends ZodSchema, TTable extends BaseTable>({ db, table, }: {
     bodySchema: T;
-    db: NodePgDatabase<any>;
+    db: NodePgDatabase<Record<string, unknown>>;
     table: TTable;
-}): (body: Partial<z.infer<T>>, { byCreator, }?: {
+}): (body: Partial<z.infer<T>> & Record<string, unknown>, { byCreator, }?: {
     byCreator?: boolean | undefined;
-}) => Promise<T["_output"]>;
+}) => Promise<z.infer<T>>;

package/es/backend/actions/get-list-data.d.ts

@@ -4,19 +4,7 @@ export declare function getListData<B extends ZodSchema>({ query, countQuery, pa
     bodySchema: B;
     current?: number;
     pageSize?: number;
-} & ReturnType<typeof getListQuery>): import("next-rest-framework/dist/index-Xbs7wi4f").R<"application/json" | "application/x-www-form-urlencoded" | "multipart/form-data", unknown, {
-    body: import("zod").ZodObject<{
-        total: import("zod").ZodNumber;
-        data: import("zod").ZodArray<B, "many">;
-    }, "strip", import("zod").ZodTypeAny, {
-        data: B["_output"][];
-        total: number;
-    }, {
-        data: B["_input"][];
-        total: number;
-    }>;
-    contentType: "application/json";
-}[], false, Promise<{
-    data: B["_output"][];
+} & ReturnType<typeof getListQuery>): () => Promise<{
+    data: any;
     total: number;
-}>>;
+}>;

package/es/backend/actions/get-list-query.d.ts

@@ -3,11 +3,11 @@ import { SelectedFields } from "drizzle-orm/pg-core/query-builders/select.types"
 import { SQL } from "drizzle-orm";
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
 export declare function getListQuery<TTable extends BaseTable, TSelection extends SelectedFields>({ db, fields, jsonArrayFields, params, relations, table, }: {
-    db: NodePgDatabase<any>;
+    db: NodePgDatabase<Record<string, unknown>>;
     fields: TSelection;
     jsonArrayFields?: string[];
     params: {
-        [field: string]: any;
+        [field: string]: unknown;
         orderBy?: keyof BaseTable;
         orderDir?: "asc" | "desc";
         page?: number;
@@ -16,13 +16,11 @@ export declare function getListQuery<TTable extends BaseTable, TSelection extend
     relations?: GetListRelations;
     table: TTable;
 }): {
-    countQuery: Omit<import("drizzle-orm/pg-core").PgSelectBase<any, {
+    countQuery: Omit<import("drizzle-orm/pg-core").PgSelectBase<string, {
         count: SQL<unknown>;
-    }, "partial", {} | Record<any, "not-null">, false, "where", ({
+    }, "partial", Record<string, "not-null">, false, "where", {
         count: unknown;
-    } | {
-        count: unknown;
-    })[], {
+    }[], {
         count: import("drizzle-orm").DrizzleTypeError<"You cannot reference this field without assigning it an alias first - use `.as(<alias>)`">;
     }>, "where">;
     query: any;

package/es/backend/actions/transform-body.d.ts

@@ -1 +1 @@
-export declare const transformBody: (body: Record<string, any>) => any;
+export declare const transformBody: <T extends Record<string, unknown>>(body: T) => T;

package/es/backend/actions/transform-body.js

@@ -1,9 +1,7 @@
 import dayjs from "dayjs";
 export var transformBody = function transformBody(body) {
-  // 遍历 body 中的每个字段
   for (var key in body) {
     if (key.endsWith("At")) {
-      // 使用 dayjs 将值转换为 Date 对象
       body[key] = dayjs(body[key]).toDate();
     }
   }

package/es/backend/route-operation/delete-operation.d.ts

@@ -10,8 +10,8 @@ export interface DeleteOperationOptions<TTable extends BaseTable> {
     byCreator?: boolean;
 }
 export declare const createDeleteOperation: ({ db, getSession, }: {
-    db: NodePgDatabase<any>;
+    db: NodePgDatabase<Record<string, unknown>>;
     getSession: (req: NextRequest) => Promise<{
         userId?: string;
     } | undefined>;
-}) => <TTable extends BaseTable>({ table, summary, onSuccess, onError, byCreator, }: DeleteOperationOptions<TTable>) => any;
+}) => <TTable extends BaseTable>({ table, summary, onSuccess, onError, byCreator, }: DeleteOperationOptions<TTable>) => import("next-rest-framework").RouteOperationDefinition<"DELETE">;

package/es/backend/route-operation/get-list-operation.d.ts

@@ -22,8 +22,8 @@ export interface GetListOperationOptions<T extends ZodSchema, Q extends ZodSchem
     onError?: (error: Error) => Promise<ReturnType<(typeof TypedNextResponse)["json"]> | undefined>;
 }
 export declare const createGetListOperation: ({ db, getSession, }: {
-    db: NodePgDatabase<any>;
+    db: NodePgDatabase<Record<string, unknown>>;
     getSession: (req: NextRequest) => Promise<{
         userId?: string;
     } | undefined>;
-}) => <T extends z.ZodType<any, z.ZodTypeDef, any>, Q extends z.ZodType<any, z.ZodTypeDef, any>, TTable extends BaseTable>({ querySchema, bodySchema, table, summary, relations, jsonArrayFields, setParams, onSuccess, onError, byCreator, }: GetListOperationOptions<T, Q, TTable>) => any;
+}) => <T extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, Q extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, TTable extends BaseTable>({ querySchema, bodySchema, table, summary, relations, jsonArrayFields, setParams, onSuccess, onError, byCreator, }: GetListOperationOptions<T, Q, TTable>) => import("next-rest-framework").RouteOperationDefinition<"GET">;

package/es/backend/route-operation/get-operation.d.ts

@@ -8,7 +8,7 @@ export interface GetOperationOptions<T extends ZodSchema, Q extends ZodSchema, T
     jsonArrayFields?: string[];
     querySchema: Q;
     relations?: GetListRelations;
-    setParams?: (req: TypedNextRequest<"GET", "application/json", unknown, z.infer<Q>>) => Promise<Record<string, any>>;
+    setParams?: (req: TypedNextRequest<"GET", "application/json", unknown, z.infer<Q>>) => Promise<Record<string, unknown>>;
     onSuccess?: (data: z.infer<T>) => Promise<z.infer<T>>;
     onError?: (error: Error) => Promise<ReturnType<(typeof TypedNextResponse)["json"]> | undefined>;
     summary?: string;
@@ -16,8 +16,8 @@ export interface GetOperationOptions<T extends ZodSchema, Q extends ZodSchema, T
     byCreator?: boolean;
 }
 export declare const createGetOperation: ({ getSession, db, }: {
-    db: NodePgDatabase<any>;
+    db: NodePgDatabase<Record<string, unknown>>;
     getSession: (req: NextRequest) => Promise<{
         userId?: string;
     } | undefined>;
-}) => <T extends z.ZodType<any, z.ZodTypeDef, any>, Q extends z.ZodType<any, z.ZodTypeDef, any>, TTable extends BaseTable>({ querySchema, bodySchema, table, summary, relations, setParams, jsonArrayFields, onSuccess, onError, byCreator, }: GetOperationOptions<T, Q, TTable>) => any;
+}) => <T extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, Q extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, TTable extends BaseTable>({ querySchema, bodySchema, table, summary, relations, setParams, jsonArrayFields, onSuccess, onError, byCreator, }: GetOperationOptions<T, Q, TTable>) => import("next-rest-framework").RouteOperationDefinition<"GET">;