sdnext 0.0.25 → 0.0.26

package/dist/utils/build.js

@@ -1,6 +1,5 @@
 import { readdir, stat } from "fs/promises";
 import { join } from "path";
-import { excludeGeneratedFiles } from "./excludeGeneratedFiles.js";
 import { runCommand } from "./runCommand.js";
 import { syncSharedArtifacts } from "./syncSharedArtifacts.js";
 async function buildFolder(dir) {
@@ -13,7 +12,6 @@ async function buildFolder(dir) {
     }
 }
 async function build(options, { args }) {
-    await excludeGeneratedFiles();
     await buildFolder("shared");
     if (0 === args.length) return;
     process.exitCode = await runCommand({

package/dist/utils/createRoute.d.ts

@@ -1,5 +1,9 @@
-export declare function createRoute(path: string): Promise<void>;
-export interface IsRouteEnabledParams {
-    content: string;
+export declare function createRoute(path?: string): Promise<void>;
+export interface SharedRouteModule {
+    importPath: string;
+    name: string;
+}
+export interface GetRouteFileContentParamsItem {
+    importPath: string;
     name: string;
 }

package/dist/utils/createRoute.js

@@ -1,31 +1,64 @@
-import { readFile } from "fs/promises";
+import { readdir } from "fs/promises";
 import { join } from "path";
-import { getSharedModuleInfo, isScriptModule, removeGeneratedFile, toKebabCase, writeGeneratedFile } from "./sharedArtifact.js";
+import { getSharedModuleInfo, isScriptModule, writeGeneratedFile } from "./sharedArtifact.js";
 async function createRoute(path) {
-    const info = getSharedModuleInfo(path);
-    if (!isScriptModule(info.relativePath)) return;
-    const routeDirPath = join("app", "api", "actions", info.dir, toKebabCase(info.name));
-    const routePath = join(routeDirPath, "route.ts");
-    const content = await readFile(join("shared", info.relativePath), "utf-8");
-    if (!isRouteEnabled({
-        content,
-        name: info.name
-    })) return void await removeGeneratedFile({
-        path: routeDirPath,
-        stopPath: join("app", "api", "actions")
-    });
+    if (path) {
+        const info = getSharedModuleInfo(path);
+        if (!isScriptModule(info.relativePath)) return;
+    }
+    const modules = await getSharedModules("shared");
     await writeGeneratedFile({
-        path: routePath,
-        content: `import { createRoute } from "@/server/createResponseFn"
+        path: join("app", "api", "action", "[...action]", "route.ts"),
+        content: getRouteFileContent(modules)
+    });
+}
+async function getSharedModules(dir) {
+    const entries = await readdir(dir, {
+        withFileTypes: true
+    });
+    const modules = [];
+    for (const entry of entries){
+        const itemPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            modules.push(...await getSharedModules(itemPath));
+            continue;
+        }
+        if (!entry.isFile() || !isScriptModule(entry.name)) continue;
+        const info = getSharedModuleInfo(itemPath);
+        modules.push({
+            importPath: info.importPath,
+            name: info.name
+        });
+    }
+    modules.sort((a, b)=>a.importPath.localeCompare(b.importPath));
+    return modules;
+}
+function getRouteFileContent(items) {
+    const importLines = items.map((item)=>`import { ${item.name} } from "@/shared/${item.importPath}"`).join("\n");
+    const registerLines = items.map((item)=>`registerRoute(${item.name})`).join("\n");
+    return `import { NextRequest, NextResponse } from "next/server"
 
-import { ${info.name} } from "@/shared/${info.importPath}"
+import { createRouteFn, OriginalResponseFn, RouteBodyType, RouteHandler } from "@/server/createResponseFn"
+${importLines ? `\n${importLines}\n` : ""}
+const routeMap = new Map<string, RouteHandler>()
 
-export const { POST } = createRoute(${info.name})
-`
-    });
+function registerRoute<TParams extends [arg?: unknown], TData, TPathname extends string, TRouteBodyType extends RouteBodyType = "json">(
+    fn: OriginalResponseFn<TParams, TData, TPathname, TRouteBodyType>,
+) {
+    if (!fn.route) return
+    const pathname = fn.route.pathname.replace(/(^\\/|\\/$)/g, "")
+    if (routeMap.has(pathname)) throw new Error(\`pathname \${pathname} is duplicate\`)
+    routeMap.set(pathname, createRouteFn(fn))
+}
+
+${registerLines ? `${registerLines}\n\n` : ""}export function POST(request: NextRequest) {
+    const { pathname } = new URL(request.url)
+    const routeHandler = routeMap.get(pathname.replace(/(^\\/api\\/action\\/|\\/$)/g, ""))
+
+    if (!routeHandler) return NextResponse.json({ success: false, data: undefined, message: "Not Found", code: 404 }, { status: 404 })
+
+    return routeHandler(request)
 }
-function isRouteEnabled({ content, name }) {
-    const routeRegExp = new RegExp(`\\b${name}\\.route\\s*=\\s*(true\\b|\\{)`);
-    return routeRegExp.test(content);
+`;
 }
 export { createRoute };

package/dist/utils/dev.js

@@ -1,10 +1,8 @@
 import { spawn } from "child_process";
 import { fileURLToPath } from "url";
 import { buildFolder } from "./build.js";
-import { excludeGeneratedFiles } from "./excludeGeneratedFiles.js";
 import { spawnCommand } from "./runCommand.js";
 async function dev(options, { args }) {
-    await excludeGeneratedFiles();
     await buildFolder("shared");
     if (0 === args.length) return;
     const watchPath = fileURLToPath(new URL("./watch.js", import.meta.url));

package/dist/utils/hook.d.ts

@@ -4,9 +4,15 @@ export type OperationType = HookType | "skip";
 export type HookContentMap = Record<HookType, string>;
 export interface HookData extends HookContentMap {
     hookPath: string;
+    mutationPreset: string;
+    mutationPresetPath: string;
     overwrite: boolean;
     type: HookType;
 }
+export interface GeneratedFileState {
+    content: string;
+    overwrite: boolean;
+}
 export declare function createHook(path: string, hookMap: Record<string, HookData>): Promise<void>;
 export declare function createHookFromFolder(): Promise<Record<string, HookData>>;
 export declare function hook(options: Record<string, string>, { args }: Command): Promise<void>;

package/dist/utils/hook.js

@@ -20,9 +20,24 @@ async function getHookTypeFromContent(path, content) {
     const type = setting.hook?.[path];
     if (void 0 !== type && "skip" !== type) return type;
     if (content.includes("useMutation")) return "mutation";
+    if (content.includes("createUse") && content.includes("@/presets/")) return "mutation";
     if (content.includes("ClientOptional")) return "get";
     if (content.includes("useQuery")) return "query";
 }
+async function getGeneratedFileState(path) {
+    try {
+        const content = await readFile(path, "utf-8");
+        return {
+            content,
+            overwrite: !content.trim()
+        };
+    } catch (error) {
+        return {
+            content: "",
+            overwrite: true
+        };
+    }
+}
 async function createHook(path, hookMap) {
     path = relative("actions", path).replace(/\\/g, "/");
     const { dir, name, base } = parse(path);
@@ -32,28 +47,30 @@ async function createHook(path, hookMap) {
     const actionImportPath = normalizePathSeparator(join(dir, name));
     const hookName = base.replace(/^./, (char)=>`use${char.toUpperCase()}`);
     const hookPath = join("hooks", dir, hookName);
+    const mutationPresetName = `createUse${upName}.ts`;
+    const mutationPresetPath = join("presets", dir, mutationPresetName);
+    const mutationPresetImportPath = normalizePathSeparator(join(dir, `createUse${upName}`));
     const clientInputType = `${upName}ClientInput`;
-    const mutationHook = `import { useId } from "react"
-
-import { useMutation, UseMutationOptions } from "@tanstack/react-query"
-import { createRequestFn } from "deepsea-tools"
+    const mutationHook = `import { createRequestFn } from "deepsea-tools"
 
 import { ${name}Action } from "@/actions/${actionImportPath}"
 
+import { createUse${upName} } from "@/presets/${mutationPresetImportPath}"
+
 export const ${name}Client = createRequestFn(${name}Action)
 
-export type ${clientInputType} = Parameters<typeof ${name}Client> extends [] ? void : Parameters<typeof ${name}Client>[0]
+export const use${upName} = createUse${upName}(${name}Client)
+`;
+    const mutationPreset = `import { useId } from "react"
 
-export interface Use${upName}Params<TOnMutateResult = unknown> extends Omit<
-    UseMutationOptions<Awaited<ReturnType<typeof ${name}Client>>, Error, ${clientInputType}, TOnMutateResult>,
-    "mutationFn"
-> {}
+import { withUseMutationDefaults } from "soda-tanstack-query"
 
-export function use${upName}<TOnMutateResult = unknown>({ onMutate, onSuccess, onError, onSettled, ...rest }: Use${upName}Params<TOnMutateResult> = {}) {
+import { ${name} } from "@/shared/${actionImportPath}"
+
+export const createUse${upName} = withUseMutationDefaults<typeof ${name}>(() => {
     const key = useId()
 
-    return useMutation({
-        mutationFn: ${name}Client,
+    return {
         onMutate(variables, context) {
             message.open({
                 key,
@@ -61,8 +78,6 @@ export function use${upName}<TOnMutateResult = unknown>({ onMutate, onSuccess, o
                 content: "中...",
                 duration: 0,
             })
-
-            return onMutate?.(variables, context) as TOnMutateResult | Promise<TOnMutateResult>
         },
         onSuccess(data, variables, onMutateResult, context) {
             context.client.invalidateQueries({ queryKey: ["query-${key.replace(/^.+?-/, "")}"] })
@@ -73,20 +88,13 @@ export function use${upName}<TOnMutateResult = unknown>({ onMutate, onSuccess, o
                 type: "success",
                 content: "成功",
             })
-
-            return onSuccess?.(data, variables, onMutateResult, context)
         },
         onError(error, variables, onMutateResult, context) {
             message.destroy(key)
-
-            return onError?.(error, variables, onMutateResult, context)
-        },
-        onSettled(data, error, variables, onMutateResult, context) {
-            return onSettled?.(data, error, variables, onMutateResult, context)
         },
-        ...rest,
-    })
-}
+        onSettled(data, error, variables, onMutateResult, context) {},
+    }
+})
 `;
     const getHook = `import { createRequestFn, isNonNullable } from "deepsea-tools"
 import { createUseQuery } from "soda-tanstack-query"
@@ -124,19 +132,28 @@ export const use${upName} = createUseQuery({
         mutation: mutationHook
     };
     let hookType = getHookTypeFromName(name);
-    let overwrite = true;
-    try {
-        const current = await readFile(hookPath, "utf-8");
-        if (current.trim()) overwrite = false;
-        const contentType = await getHookTypeFromContent(join(cwd(), hookPath), current);
-        if (contentType) hookType = contentType;
-        if (map[hookType] === current) return;
-    } catch (error) {
-        overwrite = true;
+    const hookState = await getGeneratedFileState(hookPath);
+    const contentType = await getHookTypeFromContent(join(cwd(), hookPath), hookState.content);
+    if (contentType) hookType = contentType;
+    if ("mutation" === hookType) {
+        const mutationPresetState = await getGeneratedFileState(mutationPresetPath);
+        if (map[hookType] === hookState.content && mutationPreset === mutationPresetState.content) return;
+        hookMap[path] = {
+            hookPath,
+            mutationPreset,
+            mutationPresetPath,
+            overwrite: hookState.overwrite && mutationPresetState.overwrite,
+            type: hookType,
+            ...map
+        };
+        return;
     }
+    if (map[hookType] === hookState.content) return;
     hookMap[path] = {
         hookPath,
-        overwrite,
+        mutationPreset,
+        mutationPresetPath,
+        overwrite: hookState.overwrite,
         type: hookType,
         ...map
     };
@@ -168,7 +185,7 @@ async function hook(options, { args }) {
     const oldEntires = entires.filter(([path, { overwrite }])=>!overwrite);
     const root = cwd();
     const setting = await getSetting();
-    for (const [path, { hookPath, overwrite, type, ...map }] of newEntires){
+    for (const [path, { hookPath, mutationPresetPath, mutationPreset, overwrite, type, ...map }] of newEntires){
         const resolved = join(root, hookPath);
         const answer = await prompts_select({
             message: path,
@@ -182,20 +199,32 @@ async function hook(options, { args }) {
         });
         setting.hook ??= {};
         setting.hook[resolved] = answer;
-        if ("skip" !== answer) await writeGeneratedFile({
-            path: hookPath,
-            content: map[answer]
-        });
+        if ("skip" !== answer) {
+            await writeGeneratedFile({
+                path: hookPath,
+                content: map[answer]
+            });
+            if ("mutation" === answer) await writeGeneratedFile({
+                path: mutationPresetPath,
+                content: mutationPreset
+            });
+        }
     }
     await writeSdNextSetting(setting);
     const overwrites = await prompts_checkbox({
         message: "Please check the hooks you want to overwrite",
         choices: oldEntires.map(([key])=>key)
     });
-    for (const [path, { hookPath, overwrite, type, ...map }] of oldEntires)if (overwrites.includes(path)) await writeGeneratedFile({
-        path: hookPath,
-        content: map[type]
-    });
+    for (const [path, { hookPath, mutationPresetPath, mutationPreset, overwrite, type, ...map }] of oldEntires)if (overwrites.includes(path)) {
+        await writeGeneratedFile({
+            path: hookPath,
+            content: map[type]
+        });
+        if ("mutation" === type) await writeGeneratedFile({
+            path: mutationPresetPath,
+            content: mutationPreset
+        });
+    }
 }
 function isNodeError(error) {
     return "object" == typeof error && null !== error;

package/dist/utils/syncSharedArtifacts.js

@@ -1,7 +1,7 @@
 import { join } from "path";
 import { createAction } from "./createAction.js";
 import { createRoute } from "./createRoute.js";
-import { getSharedModuleInfo, isScriptModule, normalizeSharedPath, removeGeneratedFile, toKebabCase } from "./sharedArtifact.js";
+import { getSharedModuleInfo, isScriptModule, normalizeSharedPath, removeGeneratedFile } from "./sharedArtifact.js";
 async function syncSharedArtifacts(path) {
     const info = getSharedModuleInfo(path);
     if (!isScriptModule(info.relativePath)) return;
@@ -15,10 +15,7 @@ async function removeSharedArtifacts(path) {
         path: join("actions", info.relativePath),
         stopPath: "actions"
     });
-    await removeGeneratedFile({
-        path: join("app", "api", "actions", info.dir, toKebabCase(info.name)),
-        stopPath: join("app", "api", "actions")
-    });
+    await createRoute();
 }
 async function removeSharedArtifactDirectory(path) {
     const relativePath = normalizeSharedPath(path);
@@ -26,9 +23,6 @@ async function removeSharedArtifactDirectory(path) {
         path: join("actions", relativePath),
         stopPath: "actions"
     });
-    await removeGeneratedFile({
-        path: join("app", "api", "actions", relativePath),
-        stopPath: join("app", "api", "actions")
-    });
+    await createRoute();
 }
 export { removeSharedArtifactDirectory, removeSharedArtifacts, syncSharedArtifacts };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sdnext",
-  "version": "0.0.25",
+  "version": "0.0.26",
   "description": "",
   "type": "module",
   "exports": {

package/src/utils/build.ts

@@ -3,7 +3,6 @@ import { join } from "path"
 
 import { Command } from "commander"
 
-import { excludeGeneratedFiles } from "./excludeGeneratedFiles"
 import { runCommand } from "./runCommand"
 import { syncSharedArtifacts } from "./syncSharedArtifacts"
 
@@ -20,8 +19,6 @@ export async function buildFolder(dir: string) {
 }
 
 export async function build(options: Record<string, string>, { args }: Command) {
-    await excludeGeneratedFiles()
-
     await buildFolder("shared")
 
     if (args.length === 0) return

package/src/utils/createRoute.ts

@@ -1,44 +1,86 @@
-import { readFile } from "fs/promises"
+import { readdir } from "fs/promises"
 import { join } from "path"
 
-import { getSharedModuleInfo, isScriptModule, removeGeneratedFile, toKebabCase, writeGeneratedFile } from "./sharedArtifact"
+import { getSharedModuleInfo, isScriptModule, writeGeneratedFile } from "./sharedArtifact"
 
-export async function createRoute(path: string) {
-    const info = getSharedModuleInfo(path)
+export async function createRoute(path?: string) {
+    if (path) {
+        const info = getSharedModuleInfo(path)
+        if (!isScriptModule(info.relativePath)) return
+    }
+
+    const modules = await getSharedModules("shared")
+
+    await writeGeneratedFile({
+        path: join("app", "api", "action", "[...action]", "route.ts"),
+        content: getRouteFileContent(modules),
+    })
+}
 
-    if (!isScriptModule(info.relativePath)) return
+export interface SharedRouteModule {
+    importPath: string
+    name: string
+}
 
-    const routeDirPath = join("app", "api", "actions", info.dir, toKebabCase(info.name))
-    const routePath = join(routeDirPath, "route.ts")
+async function getSharedModules(dir: string): Promise<SharedRouteModule[]> {
+    const entries = await readdir(dir, { withFileTypes: true })
 
-    const content = await readFile(join("shared", info.relativePath), "utf-8")
+    const modules: SharedRouteModule[] = []
 
-    if (!isRouteEnabled({ content, name: info.name })) {
-        await removeGeneratedFile({
-            path: routeDirPath,
-            stopPath: join("app", "api", "actions"),
-        })
+    for (const entry of entries) {
+        const itemPath = join(dir, entry.name)
 
-        return
-    }
+        if (entry.isDirectory()) {
+            modules.push(...(await getSharedModules(itemPath)))
+            continue
+        }
 
-    await writeGeneratedFile({
-        path: routePath,
-        content: `import { createRoute } from "@/server/createResponseFn"
+        if (!entry.isFile() || !isScriptModule(entry.name)) continue
 
-import { ${info.name} } from "@/shared/${info.importPath}"
+        const info = getSharedModuleInfo(itemPath)
 
-export const { POST } = createRoute(${info.name})
-`,
-    })
+        modules.push({
+            importPath: info.importPath,
+            name: info.name,
+        })
+    }
+
+    modules.sort((a, b) => a.importPath.localeCompare(b.importPath))
+
+    return modules
 }
 
-export interface IsRouteEnabledParams {
-    content: string
+export interface GetRouteFileContentParamsItem {
+    importPath: string
     name: string
 }
 
-function isRouteEnabled({ content, name }: IsRouteEnabledParams) {
-    const routeRegExp = new RegExp(`\\b${name}\\.route\\s*=\\s*(true\\b|\\{)`)
-    return routeRegExp.test(content)
+function getRouteFileContent(items: GetRouteFileContentParamsItem[]) {
+    const importLines = items.map(item => `import { ${item.name} } from "@/shared/${item.importPath}"`).join("\n")
+    const registerLines = items.map(item => `registerRoute(${item.name})`).join("\n")
+
+    return `import { NextRequest, NextResponse } from "next/server"
+
+import { createRouteFn, OriginalResponseFn, RouteBodyType, RouteHandler } from "@/server/createResponseFn"
+${importLines ? `\n${importLines}\n` : ""}
+const routeMap = new Map<string, RouteHandler>()
+
+function registerRoute<TParams extends [arg?: unknown], TData, TPathname extends string, TRouteBodyType extends RouteBodyType = "json">(
+    fn: OriginalResponseFn<TParams, TData, TPathname, TRouteBodyType>,
+) {
+    if (!fn.route) return
+    const pathname = fn.route.pathname.replace(/(^\\/|\\/$)/g, "")
+    if (routeMap.has(pathname)) throw new Error(\`pathname \${pathname} is duplicate\`)
+    routeMap.set(pathname, createRouteFn(fn))
+}
+
+${registerLines ? `${registerLines}\n\n` : ""}export function POST(request: NextRequest) {
+    const { pathname } = new URL(request.url)
+    const routeHandler = routeMap.get(pathname.replace(/(^\\/api\\/action\\/|\\/$)/g, ""))
+
+    if (!routeHandler) return NextResponse.json({ success: false, data: undefined, message: "Not Found", code: 404 }, { status: 404 })
+
+    return routeHandler(request)
 }
+`
+}

package/src/utils/dev.ts

@@ -4,12 +4,9 @@ import { fileURLToPath } from "url"
 import { Command } from "commander"
 
 import { buildFolder } from "./build"
-import { excludeGeneratedFiles } from "./excludeGeneratedFiles"
 import { spawnCommand } from "./runCommand"
 
 export async function dev(options: Record<string, string>, { args }: Command) {
-    await excludeGeneratedFiles()
-
     await buildFolder("shared")
 
     if (args.length === 0) return

package/src/utils/hook.ts

@@ -33,6 +33,7 @@ async function getHookTypeFromContent(path: string, content: string): Promise<Ho
     const type = setting.hook?.[path]
     if (type !== undefined && type !== "skip") return type
     if (content.includes("useMutation")) return "mutation"
+    if (content.includes("createUse") && content.includes("@/presets/")) return "mutation"
     if (content.includes("ClientOptional")) return "get"
     if (content.includes("useQuery")) return "query"
     return undefined
@@ -40,10 +41,33 @@ async function getHookTypeFromContent(path: string, content: string): Promise<Ho
 
 export interface HookData extends HookContentMap {
     hookPath: string
+    mutationPreset: string
+    mutationPresetPath: string
     overwrite: boolean
     type: HookType
 }
 
+export interface GeneratedFileState {
+    content: string
+    overwrite: boolean
+}
+
+async function getGeneratedFileState(path: string): Promise<GeneratedFileState> {
+    try {
+        const content = await readFile(path, "utf-8")
+
+        return {
+            content,
+            overwrite: !content.trim(),
+        }
+    } catch (error) {
+        return {
+            content: "",
+            overwrite: true,
+        }
+    }
+}
+
 export async function createHook(path: string, hookMap: Record<string, HookData>) {
     path = relative("actions", path).replace(/\\/g, "/")
     const { dir, name, base } = parse(path)
@@ -53,29 +77,32 @@ export async function createHook(path: string, hookMap: Record<string, HookData>
     const actionImportPath = normalizePathSeparator(join(dir, name))
     const hookName = base.replace(/^./, char => `use${char.toUpperCase()}`)
     const hookPath = join("hooks", dir, hookName)
+    const mutationPresetName = `createUse${upName}.ts`
+    const mutationPresetPath = join("presets", dir, mutationPresetName)
+    const mutationPresetImportPath = normalizePathSeparator(join(dir, `createUse${upName}`))
     const clientInputType = `${upName}ClientInput`
 
-    const mutationHook = `import { useId } from "react"
-
-import { useMutation, UseMutationOptions } from "@tanstack/react-query"
-import { createRequestFn } from "deepsea-tools"
+    const mutationHook = `import { createRequestFn } from "deepsea-tools"
 
 import { ${name}Action } from "@/actions/${actionImportPath}"
 
+import { createUse${upName} } from "@/presets/${mutationPresetImportPath}"
+
 export const ${name}Client = createRequestFn(${name}Action)
 
-export type ${clientInputType} = Parameters<typeof ${name}Client> extends [] ? void : Parameters<typeof ${name}Client>[0]
+export const use${upName} = createUse${upName}(${name}Client)
+`
+
+    const mutationPreset = `import { useId } from "react"
+
+import { withUseMutationDefaults } from "soda-tanstack-query"
 
-export interface Use${upName}Params<TOnMutateResult = unknown> extends Omit<
-    UseMutationOptions<Awaited<ReturnType<typeof ${name}Client>>, Error, ${clientInputType}, TOnMutateResult>,
-    "mutationFn"
-> {}
+import { ${name} } from "@/shared/${actionImportPath}"
 
-export function use${upName}<TOnMutateResult = unknown>({ onMutate, onSuccess, onError, onSettled, ...rest }: Use${upName}Params<TOnMutateResult> = {}) {
+export const createUse${upName} = withUseMutationDefaults<typeof ${name}>(() => {
     const key = useId()
 
-    return useMutation({
-        mutationFn: ${name}Client,
+    return {
         onMutate(variables, context) {
             message.open({
                 key,
@@ -83,8 +110,6 @@ export function use${upName}<TOnMutateResult = unknown>({ onMutate, onSuccess, o
                 content: "中...",
                 duration: 0,
             })
-
-            return onMutate?.(variables, context) as TOnMutateResult | Promise<TOnMutateResult>
         },
         onSuccess(data, variables, onMutateResult, context) {
             context.client.invalidateQueries({ queryKey: ["query-${key.replace(/^.+?-/, "")}"] })
@@ -95,20 +120,13 @@ export function use${upName}<TOnMutateResult = unknown>({ onMutate, onSuccess, o
                 type: "success",
                 content: "成功",
             })
-
-            return onSuccess?.(data, variables, onMutateResult, context)
         },
         onError(error, variables, onMutateResult, context) {
             message.destroy(key)
-
-            return onError?.(error, variables, onMutateResult, context)
         },
-        onSettled(data, error, variables, onMutateResult, context) {
-            return onSettled?.(data, error, variables, onMutateResult, context)
-        },
-        ...rest,
-    })
-}
+        onSettled(data, error, variables, onMutateResult, context) {},
+    }
+})
 `
 
     const getHook = `import { createRequestFn, isNonNullable } from "deepsea-tools"
@@ -150,21 +168,35 @@ export const use${upName} = createUseQuery({
     }
 
     let hookType = getHookTypeFromName(name)
-    let overwrite = true
+    const hookState = await getGeneratedFileState(hookPath)
 
-    try {
-        const current = await readFile(hookPath, "utf-8")
-        if (current.trim()) overwrite = false
-        const contentType = await getHookTypeFromContent(join(cwd(), hookPath), current)
-        if (contentType) hookType = contentType
-        if (map[hookType] === current) return
-    } catch (error) {
-        overwrite = true
+    const contentType = await getHookTypeFromContent(join(cwd(), hookPath), hookState.content)
+    if (contentType) hookType = contentType
+
+    if (hookType === "mutation") {
+        const mutationPresetState = await getGeneratedFileState(mutationPresetPath)
+
+        if (map[hookType] === hookState.content && mutationPreset === mutationPresetState.content) return
+
+        hookMap[path] = {
+            hookPath,
+            mutationPreset,
+            mutationPresetPath,
+            overwrite: hookState.overwrite && mutationPresetState.overwrite,
+            type: hookType,
+            ...map,
+        }
+
+        return
     }
 
+    if (map[hookType] === hookState.content) return
+
     hookMap[path] = {
         hookPath,
-        overwrite,
+        mutationPreset,
+        mutationPresetPath,
+        overwrite: hookState.overwrite,
         type: hookType,
         ...map,
     }
@@ -213,7 +245,7 @@ export async function hook(options: Record<string, string>, { args }: Command) {
 
     const setting = await getSetting()
 
-    for (const [path, { hookPath, overwrite, type, ...map }] of newEntires) {
+    for (const [path, { hookPath, mutationPresetPath, mutationPreset, overwrite, type, ...map }] of newEntires) {
         const resolved = join(root, hookPath)
 
         const answer = await select<OperationType>({
@@ -231,6 +263,13 @@ export async function hook(options: Record<string, string>, { args }: Command) {
             path: hookPath,
             content: map[answer],
         })
+
+        if (answer !== "mutation") continue
+
+        await writeGeneratedFile({
+            path: mutationPresetPath,
+            content: mutationPreset,
+        })
     }
 
     await writeSdNextSetting(setting)
@@ -240,13 +279,20 @@ export async function hook(options: Record<string, string>, { args }: Command) {
         choices: oldEntires.map(([key]) => key),
     })
 
-    for (const [path, { hookPath, overwrite, type, ...map }] of oldEntires) {
+    for (const [path, { hookPath, mutationPresetPath, mutationPreset, overwrite, type, ...map }] of oldEntires) {
         if (!overwrites.includes(path)) continue
 
         await writeGeneratedFile({
             path: hookPath,
             content: map[type],
         })
+
+        if (type !== "mutation") continue
+
+        await writeGeneratedFile({
+            path: mutationPresetPath,
+            content: mutationPreset,
+        })
     }
 }
 

package/src/utils/syncSharedArtifacts.ts

@@ -2,7 +2,7 @@ import { join } from "path"
 
 import { createAction } from "./createAction"
 import { createRoute } from "./createRoute"
-import { getSharedModuleInfo, isScriptModule, normalizeSharedPath, removeGeneratedFile, toKebabCase } from "./sharedArtifact"
+import { getSharedModuleInfo, isScriptModule, normalizeSharedPath, removeGeneratedFile } from "./sharedArtifact"
 
 export async function syncSharedArtifacts(path: string) {
     const info = getSharedModuleInfo(path)
@@ -23,10 +23,7 @@ export async function removeSharedArtifacts(path: string) {
         stopPath: "actions",
     })
 
-    await removeGeneratedFile({
-        path: join("app", "api", "actions", info.dir, toKebabCase(info.name)),
-        stopPath: join("app", "api", "actions"),
-    })
+    await createRoute()
 }
 
 export async function removeSharedArtifactDirectory(path: string) {
@@ -37,8 +34,5 @@ export async function removeSharedArtifactDirectory(path: string) {
         stopPath: "actions",
     })
 
-    await removeGeneratedFile({
-        path: join("app", "api", "actions", relativePath),
-        stopPath: join("app", "api", "actions"),
-    })
-}
+    await createRoute()
+}

package/dist/utils/excludeGeneratedFiles.d.ts

@@ -1 +0,0 @@
-export declare function excludeGeneratedFiles(): Promise<import("./writeVsCodeSetting").VsCodeSetting>;

package/dist/utils/excludeGeneratedFiles.js

@@ -1,10 +0,0 @@
-import { writeVsCodeSetting } from "./writeVsCodeSetting.js";
-function excludeGeneratedFiles() {
-    return writeVsCodeSetting({
-        "files.exclude": {
-            "actions/**": true,
-            "app/api/actions/**": true
-        }
-    });
-}
-export { excludeGeneratedFiles };

package/dist/utils/writeVsCodeSetting.d.ts

@@ -1,7 +0,0 @@
-export interface VsCodeSetting {
-    [key: string]: unknown;
-}
-export declare function writeVsCodeSetting(config: VsCodeSetting): Promise<VsCodeSetting>;
-export interface NodeError {
-    code?: string;
-}

package/dist/utils/writeVsCodeSetting.js

@@ -1,22 +0,0 @@
-import { mkdir, readFile, writeFile } from "fs/promises";
-import { merge } from "deepsea-tools";
-async function writeVsCodeSetting(config) {
-    await mkdir(".vscode", {
-        recursive: true
-    });
-    let data;
-    try {
-        const json = await readFile(".vscode/settings.json", "utf-8");
-        data = JSON.parse(json);
-    } catch (error) {
-        if (!isNodeError(error) || "ENOENT" !== error.code) throw new Error("Failed to read .vscode/settings.json. Please ensure it is a valid JSON file.");
-        data = {};
-    }
-    data = merge(data, config);
-    await writeFile(".vscode/settings.json", JSON.stringify(data, null, 4));
-    return data;
-}
-function isNodeError(error) {
-    return "object" == typeof error && null !== error;
-}
-export { writeVsCodeSetting };

package/src/utils/excludeGeneratedFiles.ts

@@ -1,10 +0,0 @@
-import { writeVsCodeSetting } from "./writeVsCodeSetting"
-
-export function excludeGeneratedFiles() {
-    return writeVsCodeSetting({
-        "files.exclude": {
-            "actions/**": true,
-            "app/api/actions/**": true,
-        },
-    })
-}

package/src/utils/writeVsCodeSetting.ts

@@ -1,38 +0,0 @@
-import { mkdir, readFile, writeFile } from "fs/promises"
-
-import { merge } from "deepsea-tools"
-
-export interface VsCodeSetting {
-    [key: string]: unknown
-}
-
-export async function writeVsCodeSetting(config: VsCodeSetting) {
-    await mkdir(".vscode", { recursive: true })
-
-    let data: VsCodeSetting
-
-    try {
-        const json = await readFile(".vscode/settings.json", "utf-8")
-        data = JSON.parse(json) as VsCodeSetting
-    } catch (error) {
-        if (!isNodeError(error) || error.code !== "ENOENT") {
-            throw new Error("Failed to read .vscode/settings.json. Please ensure it is a valid JSON file.")
-        }
-
-        data = {}
-    }
-
-    data = merge(data, config) as VsCodeSetting
-
-    await writeFile(".vscode/settings.json", JSON.stringify(data, null, 4))
-
-    return data
-}
-
-export interface NodeError {
-    code?: string
-}
-
-function isNodeError(error: unknown): error is NodeError {
-    return typeof error === "object" && error !== null
-}