sdnext 0.0.7 → 0.0.9

package/dist/utils/hook.d.ts

@@ -1,5 +1,6 @@
 import { Command } from "commander";
 export type HookType = "get" | "query" | "mutation";
+export type OperationType = HookType | "skip";
 export type HookContentMap = Record<HookType, string>;
 export interface HookData extends HookContentMap {
     overwrite: boolean;

package/dist/utils/hook.js

@@ -1,12 +1,23 @@
 import { mkdir, readFile, readdir, stat, writeFile } from "fs/promises";
 import { join, parse, relative } from "path";
+import { cwd } from "process";
 import { checkbox as prompts_checkbox, select as prompts_select } from "@inquirer/prompts";
+import { readSdNextSetting } from "./readSdNextSetting.js";
+import { writeSdNextSetting } from "./writeSdNextSetting.js";
 function getHookTypeFromName(name) {
     if (/^get[^a-z]/.test(name)) return "get";
     if (/^query[^a-z]/.test(name)) return "query";
     return "mutation";
 }
-function getHookTypeFromContent(content) {
+let hook_setting = {};
+async function getSetting() {
+    hook_setting = await readSdNextSetting();
+    return hook_setting;
+}
+async function getHookTypeFromContent(path, content) {
+    const setting = await getSetting();
+    const type = setting.hook?.[path];
+    if (void 0 !== type && "skip" !== type) return type;
     if (content.includes("useMutation")) return "mutation";
     if (content.includes("IdOrParams")) return "get";
     if (content.includes("useQuery")) return "query";
@@ -20,7 +31,9 @@ async function createHook(path, hookMap) {
     const hasSchema = !!match;
     const upName = name.replace(/^./, (char)=>char.toUpperCase());
     const key = name.replace(/[A-Z]/g, (char)=>`-${char.toLowerCase()}`);
-    const mutationHook = `import { useMutation, UseMutationOptions } from "@tanstack/react-query"
+    const mutationHook = `import { useId } from "react"
+
+import { useMutation, UseMutationOptions } from "@tanstack/react-query"
 import { createRequestFn } from "deepsea-tools"
 
 import { ${name}Action } from "@/actions/${join(dir, name)}"
@@ -38,15 +51,34 @@ export interface Use${upName}Params<TOnMutateResult = unknown> extends Omit<
 > {}
 
 export function use${upName}<TOnMutateResult = unknown>({ onMutate, onSuccess, onError, onSettled, ...rest }: Use${upName}Params<TOnMutateResult> = {}) {
+    const key = useId()
+
     return useMutation({
         mutationFn: ${name}Client,
         onMutate(variables, context) {
+            message.open({
+                key,
+                type: "loading",
+                content: "中...",
+                duration: 0,
+            })
             return onMutate?.(variables, context) as TOnMutateResult | Promise<TOnMutateResult>
         },
         onSuccess(data, variables, onMutateResult, context) {
+            context.client.invalidateQueries({ queryKey: ["query-${key.replace(/^.+-/, "")}"] })
+            context.client.invalidateQueries({ queryKey: ["get-${key.replace(/^.+-/, "")}", data.id] })
+
+            message.open({
+                key,
+                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) {
@@ -103,13 +135,14 @@ export const use${upName} = createUseQuery({
         query: queryHook,
         mutation: mutationHook
     };
-    const hookPath = join("hooks", dir, base.replace(/^./, (char)=>`use${char.toUpperCase()}`));
+    const hookName = base.replace(/^./, (char)=>`use${char.toUpperCase()}`);
+    const hookPath = join("hooks", dir, hookName);
     let hookType = getHookTypeFromName(name);
     let overwrite = true;
     try {
         const current = await readFile(hookPath, "utf-8");
         if (current.trim()) overwrite = false;
-        const contentType = getHookTypeFromContent(current);
+        const contentType = await getHookTypeFromContent(join(cwd(), hookPath), current);
         if (contentType) hookType = contentType;
         if (map[hookType] === current) return;
     } catch (error) {
@@ -141,7 +174,10 @@ async function hook(options, { args }) {
     if (0 === entires.length) return void console.log("All hooks are the latest.");
     const newEntires = entires.filter(([path, { overwrite }])=>overwrite);
     const oldEntires = entires.filter(([path, { overwrite }])=>!overwrite);
+    const root = cwd();
+    const setting = await getSetting();
     for await (const [path, { overwrite, type, ...map }] of newEntires){
+        const resolved = join(root, "hooks", path);
         const answer = await prompts_select({
             message: path,
             choices: [
@@ -150,8 +186,10 @@ async function hook(options, { args }) {
                 "get",
                 "skip"
             ],
-            default: type
+            default: setting.hook?.[resolved] ?? type
         });
+        setting.hook ??= {};
+        setting.hook[resolved] = answer;
         if ("skip" === answer) continue;
         const { dir, base } = parse(path);
         await mkdir(join("hooks", dir), {
@@ -159,11 +197,12 @@ async function hook(options, { args }) {
         });
         await writeFile(join("hooks", dir, base.replace(/^./, (char)=>`use${char.toUpperCase()}`)), map[answer]);
     }
+    await writeSdNextSetting(setting);
     const overwrites = await prompts_checkbox({
         message: "Please check the hooks you want to overwrite",
         choices: oldEntires.map(([key])=>key)
     });
-    for await (const [path, { overwrite, type, ...map }] of oldEntires){
+    for (const [path, { overwrite, type, ...map }] of oldEntires){
         if (!overwrites.includes(path)) continue;
         const { dir, base } = parse(path);
         await mkdir(join("hooks", dir), {

package/dist/utils/readSdNextSetting.d.ts

@@ -0,0 +1,5 @@
+import { OperationType } from "./hook";
+export interface SdNextSetting {
+    hook?: Record<string, OperationType>;
+}
+export declare function readSdNextSetting(): Promise<SdNextSetting>;

package/dist/utils/readSdNextSetting.js

@@ -0,0 +1,14 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+async function readSdNextSetting() {
+    const userDir = homedir();
+    const settingPath = join(userDir, ".sdnext.json");
+    if (existsSync(settingPath)) {
+        const setting = JSON.parse(await readFile(settingPath, "utf-8"));
+        return setting;
+    }
+    return {};
+}
+export { readSdNextSetting };

package/dist/utils/writeSdNextSetting.d.ts

@@ -0,0 +1,2 @@
+import { SdNextSetting } from "./readSdNextSetting";
+export declare function writeSdNextSetting(setting: SdNextSetting): Promise<void>;

package/dist/utils/writeSdNextSetting.js

@@ -0,0 +1,9 @@
+import { writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+async function writeSdNextSetting(setting) {
+    const userDir = homedir();
+    const settingPath = join(userDir, ".sdnext.json");
+    await writeFile(settingPath, JSON.stringify(setting, void 0, 4), "utf-8");
+}
+export { writeSdNextSetting };

package/package.json

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

package/src/utils/hook.ts

@@ -1,11 +1,17 @@
 import { mkdir, readdir, readFile, stat, writeFile } from "fs/promises"
 import { join, parse, relative } from "path"
+import { cwd } from "process"
 
 import { checkbox, select } from "@inquirer/prompts"
 import { Command } from "commander"
 
+import { readSdNextSetting, SdNextSetting } from "./readSdNextSetting"
+import { writeSdNextSetting } from "./writeSdNextSetting"
+
 export type HookType = "get" | "query" | "mutation"
 
+export type OperationType = HookType | "skip"
+
 export type HookContentMap = Record<HookType, string>
 
 function getHookTypeFromName(name: string): HookType {
@@ -14,7 +20,17 @@ function getHookTypeFromName(name: string): HookType {
     return "mutation"
 }
 
-function getHookTypeFromContent(content: string): HookType | undefined {
+let setting: SdNextSetting = {}
+
+async function getSetting() {
+    setting = await readSdNextSetting()
+    return setting
+}
+
+async function getHookTypeFromContent(path: string, content: string): Promise<HookType | undefined> {
+    const setting = await getSetting()
+    const type = setting.hook?.[path]
+    if (type !== undefined && type !== "skip") return type
     if (content.includes("useMutation")) return "mutation"
     if (content.includes("IdOrParams")) return "get"
     if (content.includes("useQuery")) return "query"
@@ -36,7 +52,9 @@ export async function createHook(path: string, hookMap: Record<string, HookData>
     const upName = name.replace(/^./, char => char.toUpperCase())
     const key = name.replace(/[A-Z]/g, char => `-${char.toLowerCase()}`)
 
-    const mutationHook = `import { useMutation, UseMutationOptions } from "@tanstack/react-query"
+    const mutationHook = `import { useId } from "react"
+
+import { useMutation, UseMutationOptions } from "@tanstack/react-query"
 import { createRequestFn } from "deepsea-tools"
 
 import { ${name}Action } from "@/actions/${join(dir, name)}"
@@ -62,15 +80,34 @@ export interface Use${upName}Params<TOnMutateResult = unknown> extends Omit<
 > {}
 
 export function use${upName}<TOnMutateResult = unknown>({ onMutate, onSuccess, onError, onSettled, ...rest }: Use${upName}Params<TOnMutateResult> = {}) {
+    const key = useId()
+
     return useMutation({
         mutationFn: ${name}Client,
         onMutate(variables, context) {
+            message.open({
+                key,
+                type: "loading",
+                content: "中...",
+                duration: 0,
+            })
             return onMutate?.(variables, context) as TOnMutateResult | Promise<TOnMutateResult>
         },
         onSuccess(data, variables, onMutateResult, context) {
+            context.client.invalidateQueries({ queryKey: ["query-${key.replace(/^.+-/, "")}"] })
+            context.client.invalidateQueries({ queryKey: ["get-${key.replace(/^.+-/, "")}", data.id] })
+
+            message.open({
+                key,
+                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) {
@@ -147,11 +184,9 @@ export const use${upName} = createUseQuery({
         mutation: mutationHook,
     }
 
-    const hookPath = join(
-        "hooks",
-        dir,
-        base.replace(/^./, char => `use${char.toUpperCase()}`),
-    )
+    const hookName = base.replace(/^./, char => `use${char.toUpperCase()}`)
+
+    const hookPath = join("hooks", dir, hookName)
 
     let hookType = getHookTypeFromName(name)
     let overwrite = true
@@ -159,7 +194,7 @@ export const use${upName} = createUseQuery({
     try {
         const current = await readFile(hookPath, "utf-8")
         if (current.trim()) overwrite = false
-        const contentType = getHookTypeFromContent(current)
+        const contentType = await getHookTypeFromContent(join(cwd(), hookPath), current)
         if (contentType) hookType = contentType
         if (map[hookType] === current) return
     } catch (error) {
@@ -207,15 +242,22 @@ export async function hook(options: Record<string, string>, { args }: Command) {
 
     const oldEntires = entires.filter(([path, { overwrite }]) => !overwrite)
 
+    const root = cwd()
+
+    const setting = await getSetting()
+
     for await (const [path, { overwrite, type, ...map }] of newEntires) {
-        type OperationType = HookType | "skip"
+        const resolved = join(root, "hooks", path)
 
         const answer = await select<OperationType>({
             message: path,
             choices: ["mutation", "query", "get", "skip"],
-            default: type,
+            default: setting.hook?.[resolved] ?? type,
         })
 
+        setting.hook ??= {}
+        setting.hook[resolved] = answer
+
         if (answer === "skip") continue
 
         const { dir, base } = parse(path)
@@ -230,12 +272,14 @@ export async function hook(options: Record<string, string>, { args }: Command) {
         )
     }
 
+    await writeSdNextSetting(setting)
+
     const overwrites = await checkbox<string>({
         message: "Please check the hooks you want to overwrite",
         choices: oldEntires.map(([key]) => key),
     })
 
-    for await (const [path, { overwrite, type, ...map }] of oldEntires) {
+    for (const [path, { overwrite, type, ...map }] of oldEntires) {
         if (!overwrites.includes(path)) continue
 
         const { dir, base } = parse(path)

package/src/utils/readSdNextSetting.ts

@@ -0,0 +1,22 @@
+import { existsSync } from "node:fs"
+import { readFile } from "node:fs/promises"
+import { homedir } from "node:os"
+import { join } from "node:path"
+
+import { OperationType } from "./hook"
+
+export interface SdNextSetting {
+    hook?: Record<string, OperationType>
+}
+
+export async function readSdNextSetting(): Promise<SdNextSetting> {
+    const userDir = homedir()
+    const settingPath = join(userDir, ".sdnext.json")
+
+    if (existsSync(settingPath)) {
+        const setting = JSON.parse(await readFile(settingPath, "utf-8"))
+        return setting
+    }
+
+    return {}
+}

package/src/utils/writeSdNextSetting.ts

@@ -0,0 +1,11 @@
+import { writeFile } from "node:fs/promises"
+import { homedir } from "node:os"
+import { join } from "node:path"
+
+import { SdNextSetting } from "./readSdNextSetting"
+
+export async function writeSdNextSetting(setting: SdNextSetting) {
+    const userDir = homedir()
+    const settingPath = join(userDir, ".sdnext.json")
+    await writeFile(settingPath, JSON.stringify(setting, undefined, 4), "utf-8")
+}