zixulu 1.81.0 → 1.81.2

package/dist/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import chalk from "chalk";
-import { Command } from "commander";
+import { Command, Option } from "commander";
 import consola, { consola as external_consola_consola } from "consola";
 import { capitalize, emailReg, getEnumEntries, getEnumKeys, getEnumValues, isNonNullable, json2type } from "deepsea-tools";
 import { compress, execAsync, isPathLike, setDefaultOptions, spawnAsync, unzip, zip } from "soda-nodejs";
@@ -357,6 +357,10 @@ export default Registry
 `);
     consola.success("添加 antd 配置成功");
 }
+const AddApiIdType = {
+    字符串: "string",
+    数字: "number"
+};
 async function addApi_writeFile(...args) {
     const [path] = args;
     if (isPathLike(path) && existsSync(path)) {
@@ -369,8 +373,9 @@ async function addApi_writeFile(...args) {
     }
     return await writeFile(...args);
 }
-async function addApi({ type, api, hook }) {
+async function addApi({ type, api, hook, idType = AddApiIdType.字符串, name }) {
     type = capitalize(type);
+    name ??= type;
     api ??= "apis";
     hook ??= "hooks";
     await mkdir(api, {
@@ -392,7 +397,7 @@ async function addApi({ type, api, hook }) {
             "delete"
         ]
     });
-    const query = `import { Page } from "deepsea-tools"
+    const query = `import type { Page } from "deepsea-tools"
 
 import { request } from "@/utils/request"
 
@@ -402,14 +407,10 @@ export interface Query${type}Params {
 }
 
 export interface ${type} {
-    id: string
+    id: ${idType}
     name: string
 }
 
-export type ${type}Id = ${type}["id"]
-
-export const ${type}Name = "${type}"
-
 export async function query${type}(params: Query${type}Params) {
     const response = await request<Page<${type}>>("/${type2}/query", {
         method: "POST",
@@ -417,11 +418,18 @@ export async function query${type}(params: Query${type}Params) {
     })
     return response
 }
+
+export async function getAll${type}() {
+    const response = await request<${type}[]>("/${type2}/getAll", {
+        method: "POST",
+    })
+    return response
+}
 `;
     if (items.includes("query")) await addApi_writeFile(join(api, `query${type}.ts`), query);
     const add = `import { request } from "@/utils/request"
 
-import { ${type} } from "./query${type}"
+import type { ${type} } from "./query${type}"
 
 export interface Add${type}Params extends Pick<${type}, "name"> {}
 
@@ -436,7 +444,7 @@ export async function add${type}(params: Add${type}Params) {
     if (items.includes("add")) await addApi_writeFile(join(api, `add${type}.ts`), add);
     const update = `import { request } from "@/utils/request"
 
-import { ${type} } from "./query${type}"
+import type { ${type} } from "./query${type}"
 
 export interface Update${type}Params extends Pick<${type}, "id" | "name"> {}
 
@@ -451,11 +459,9 @@ export async function update${type}(params: Update${type}Params) {
     if (items.includes("update")) await addApi_writeFile(join(api, `update${type}.ts`), update);
     const _delete = `import { request } from "@/utils/request"
 
-import { ${type}, ${type}Id } from "./query${type}"
-
-export type Delete${type}Params = ${type}Id
+import type { ${type} } from "./query${type}"
 
-export async function delete${type}(id: Delete${type}Params) {
+export async function delete${type}(id: ${idType}) {
     const response = await request<${type}>(\`/${type2}/delete/\${id}\`, {
         method: "DELETE",
     })
@@ -465,11 +471,9 @@ export async function delete${type}(id: Delete${type}Params) {
     if (items.includes("delete")) await addApi_writeFile(join(api, `delete${type}.ts`), _delete);
     const get = `import { request } from "@/utils/request"
 
-import { ${type}, ${type}Id } from "./query${type}"
-
-export type Get${type}Params = ${type}Id
+import type { ${type} } from "./query${type}"
 
-export async function get${type}(id: Get${type}Params) {
+export async function get${type}(id: ${idType}) {
     const response = await request<${type}>(\`/${type2}/get/\${id}\`, {
         method: "POST",
     })
@@ -477,185 +481,147 @@ export async function get${type}(id: Get${type}Params) {
 }
 `;
     if (items.includes("get")) await addApi_writeFile(join(api, `get${type}.ts`), get);
-    const useQuery = `import { useQuery } from "@tanstack/react-query"
+    const useQuery = `import { createUseQuery } from "soda-tanstack-query"
 
-import { Query${type}Params, query${type} } from "@/apis/query${type}"
+import { getAll${type}, query${type} } from "@/apis/query${type}"
 
-export function useQuery${type}(params: Query${type}Params) {
-    return useQuery({
-        queryKey: ["query-${type2}", params],
-        queryFn: () => query${type}(params),
-    })
-}
+export const useQuery${type} = createUseQuery({
+    queryFn: query${type},
+    queryKey: "query-${type2}",
+})
+
+export const useGetAll${type} = createUseQuery({
+    queryFn: getAll${type},
+    queryKey: "get-all-${type2}",
+    staleTime: Infinity,
+    gcTime: Infinity,
+})
 `;
     if (items.includes("query")) await addApi_writeFile(join(hook, `useQuery${type}.ts`), useQuery);
-    const useGet = `import { useQuery } from "@tanstack/react-query"
-import { isNonNullable, resolveNull } from "deepsea-tools"
+    const useGet = `import { isNonNullable } from "deepsea-tools"
+import { createUseQuery } from "soda-tanstack-query"
 
-import { Get${type}Params, get${type} } from "@/apis/get${type}"
+import { get${type} } from "@/apis/get${type}"
 
-export interface UseGet${type}Params {
-    id?: Get${type}Params | undefined
-    enabled?: boolean
+export function get${type}Optional(params?: Parameters<typeof get${type}>[0] | undefined) {
+    return isNonNullable(params) ? get${type}(params) : null
 }
 
-export function useGet${type}(idOrParams?: UseGet${type}Params | Get${type}Params | undefined) {
-    const { id, enabled = true } = typeof idOrParams === "object" ? idOrParams : { id: idOrParams, enabled: true }
-
-    return useQuery({
-        queryKey: ["get-${type2}", id],
-        queryFn: isNonNullable(id) ? () => get${type}(id) : resolveNull,
-        enabled,
-    })
-}
+export const useGet${type} = createUseQuery({
+    queryFn: get${type}Optional,
+    queryKey: "get-${type2}",
+})
 `;
     if (items.includes("get")) await addApi_writeFile(join(hook, `useGet${type}.ts`), useGet);
     const useAdd = `import { useId } from "react"
-import { UseMutationOptions, useMutation, useQueryClient } from "@tanstack/react-query"
 
-import { Add${type}Params, add${type} } from "@/apis/add${type}"
-import { ${type}, ${type}Name } from "@/apis/query${type}"
+import { createUseMutation } from "soda-tanstack-query"
 
-export interface UseAdd${type}Params<TContext = never>
-    extends Omit<UseMutationOptions<${type}, Error, Add${type}Params, TContext>, "mutationFn"> {}
+import { add${type} } from "@/apis/add${type}"
 
-export function useAdd${type}<TContext = never>({ onMutate, onSuccess, onError, onSettled, ...rest }: UseAdd${type}Params<TContext> = {}) {
+export const useAdd${type} = createUseMutation(() => {
     const key = useId()
-    const queryClient = useQueryClient()
 
-    return useMutation({
+    return {
         mutationFn: add${type},
-        onMutate(variables) {
+        onMutate(variables, context) {
             message.open({
                 key,
                 type: "loading",
-                content: \`新增\${${type}Name}中...\`,
+                content: ${JSON.stringify(`新增${name}中...`)},
                 duration: 0,
             })
-            return onMutate?.(variables)
         },
-        onSuccess(data, variables, context) {
+        onSuccess(data, variables, onMutateResult, context) {
+            context.client.invalidateQueries({ queryKey: ["query-${type2}"] })
+            context.client.invalidateQueries({ queryKey: ["get-${type2}"] })
+
             message.open({
                 key,
                 type: "success",
-                content: \`新增\${${type}Name}成功\`,
-            })
-            return onSuccess?.(data, variables, context)
-        },
-        onError(error, variables, context) {
-            message.open({
-                key,
-                type: "error",
-                content: \`新增\${${type}Name}失败\`,
+                content: ${JSON.stringify(`新增${name}成功`)},
             })
-            return onError?.(error, variables, context)
         },
-        onSettled(data, error, variables, context) {
-            queryClient.invalidateQueries({ queryKey: ["query-${type2}"] })
-            return onSettled?.(data, error, variables, context)
+        onError(error, variables, onMutateResult, context) {
+            message.destroy(key)
         },
-        ...rest,
-    })
-}
+        onSettled(data, error, variables, onMutateResult, context) {},
+    }
+})
 `;
     if (items.includes("add")) await addApi_writeFile(join(hook, `useAdd${type}.ts`), useAdd);
     const useUpdate = `import { useId } from "react"
-import { UseMutationOptions, useMutation, useQueryClient } from "@tanstack/react-query"
 
-import { ${type}, ${type}Name } from "@/apis/query${type}"
-import { Update${type}Params, update${type} } from "@/apis/update${type}"
+import { createUseMutation } from "soda-tanstack-query"
 
-export interface UseUpdate${type}Params<TContext = never>
-    extends Omit<UseMutationOptions<${type}, Error, Update${type}Params, TContext>, "mutationFn"> {}
+import { update${type} } from "@/apis/update${type}"
 
-export function useUpdate${type}<TContext = never>({ onMutate, onSuccess, onError, onSettled, ...rest }: UseUpdate${type}Params<TContext> = {}) {
+export const useUpdate${type} = createUseMutation(() => {
     const key = useId()
-    const queryClient = useQueryClient()
 
-    return useMutation({
+    return {
         mutationFn: update${type},
-        onMutate(variables) {
+        onMutate(variables, context) {
             message.open({
                 key,
                 type: "loading",
-                content: \`更新\${${type}Name}中...\`,
+                content: ${JSON.stringify(`修改${name}中...`)},
                 duration: 0,
             })
-            return onMutate?.(variables)
         },
-        onSuccess(data, variables, context) {
+        onSuccess(data, variables, onMutateResult, context) {
+            context.client.invalidateQueries({ queryKey: ["query-${type2}"] })
+            context.client.invalidateQueries({ queryKey: ["get-${type2}"] })
+
             message.open({
                 key,
                 type: "success",
-                content: \`更新\${${type}Name}成功\`,
+                content: ${JSON.stringify(`修改${name}成功`)},
             })
-            return onSuccess?.(data, variables, context)
         },
-        onError(error, variables, context) {
-            message.open({
-                key,
-                type: "error",
-                content: \`更新\${${type}Name}失败\`,
-            })
-            return onError?.(error, variables, context)
+        onError(error, variables, onMutateResult, context) {
+            message.destroy(key)
         },
-        onSettled(data, error, variables, context) {
-            queryClient.invalidateQueries({ queryKey: ["get-${type2}", variables.id] })
-            queryClient.invalidateQueries({ queryKey: ["query-${type2}"] })
-            return onSettled?.(data, error, variables, context)
-        },
-        ...rest,
-    })
-}
+        onSettled(data, error, variables, onMutateResult, context) {},
+    }
+})
 `;
     if (items.includes("update")) await addApi_writeFile(join(hook, `useUpdate${type}.ts`), useUpdate);
     const useDelete = `import { useId } from "react"
-import { UseMutationOptions, useMutation, useQueryClient } from "@tanstack/react-query"
 
-import { Delete${type}Params, delete${type} } from "@/apis/delete${type}"
-import { ${type}, ${type}Name } from "@/apis/query${type}"
+import { createUseMutation } from "soda-tanstack-query"
 
-export interface UseDelete${type}Params<TContext = never>
-    extends Omit<UseMutationOptions<${type}, Error, Delete${type}Params, TContext>, "mutationFn"> {}
+import { delete${type} } from "@/apis/delete${type}"
 
-export function useDelete${type}<TContext = never>({ onMutate, onSuccess, onError, onSettled, ...rest }: UseDelete${type}Params<TContext> = {}) {
+export const useDelete${type} = createUseMutation(() => {
     const key = useId()
-    const queryClient = useQueryClient()
 
-    return useMutation({
+    return {
         mutationFn: delete${type},
-        onMutate(variables) {
+        onMutate(variables, context) {
             message.open({
                 key,
                 type: "loading",
-                content: \`删除\${${type}Name}中...\`,
+                content: ${JSON.stringify(`删除${name}中...`)},
                 duration: 0,
             })
-            return onMutate?.(variables)
         },
-        onSuccess(data, variables, context) {
+        onSuccess(data, variables, onMutateResult, context) {
+            context.client.invalidateQueries({ queryKey: ["query-${type2}"] })
+            context.client.invalidateQueries({ queryKey: ["get-${type2}"] })
+
             message.open({
                 key,
                 type: "success",
-                content: \`删除\${${type}Name}成功\`,
-            })
-            return onSuccess?.(data, variables, context)
-        },
-        onError(error, variables, context) {
-            message.open({
-                key,
-                type: "error",
-                content: \`删除\${${type}Name}失败\`,
+                content: ${JSON.stringify(`删除${name}成功`)},
             })
-            return onError?.(error, variables, context)
         },
-        onSettled(data, error, variables, context) {
-            queryClient.invalidateQueries({ queryKey: ["query-${type2}"] })
-            return onSettled?.(data, error, variables, context)
+        onError(error, variables, onMutateResult, context) {
+            message.destroy(key)
         },
-        ...rest,
-    })
-}
+        onSettled(data, error, variables, onMutateResult, context) {},
+    }
+})
 `;
     if (items.includes("delete")) await addApi_writeFile(join(hook, `useDelete${type}.ts`), useDelete);
 }
@@ -4900,7 +4866,7 @@ async function asyncAgentRules() {
         });
         if (0 === selectedFiles.length) throw new Error("未选择 Agent 规则");
         await syncAgentsMdRules(rules.filter((rule)=>selectedFiles.includes(rule.filename)));
-        return getCommitMessage("feat", "同步 Agent 规则");
+        return getCommitMessage("feat", "sync agent rule");
     } finally{
         await rm(syncAgentRules_source, {
             recursive: true,
@@ -6489,10 +6455,12 @@ program.command("set-env").description("设置环境变量").argument("key", "
     await setEnv(key, value);
     consola.success("设置环境变量成功");
 });
-program.command("add-api").description("添加 api 文件").argument("type", "api 类型").option("-a, --api <api>", "api 文件夹路径").option("-h, --hook <hook>", "hook 文件夹路径").action(async (type, { api, hook })=>addApi({
+program.command("add-api").description("添加 api 文件").argument("type", "api 类型").option("-a, --api <api>", "api 文件夹路径").option("-h, --hook <hook>", "hook 文件夹路径").addOption(new Option("--id-type <idType>", "id 类型，可选 string 或 number").choices(Object.values(AddApiIdType)).default(AddApiIdType["字符串"])).option("-n, --name <name>", "名称，默认与 type 一致").action(async (type, { api, hook, idType, name })=>addApi({
         type,
         api,
-        hook
+        hook,
+        idType,
+        name
     }));
 program.command("rslib").description("rslib 配置").action(rslib);
 program.command("init-node").description("初始化 node 项目").action(initNode);