sdnext 0.0.24 → 0.0.26

package/dist/utils/hook.js

@@ -1,8 +1,9 @@
-import { mkdir, readFile, readdir, stat, writeFile } from "fs/promises";
+import { readFile, readdir, stat } 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 { isScriptModule, normalizePathSeparator, writeGeneratedFile } from "./sharedArtifact.js";
 import { writeSdNextSetting } from "./writeSdNextSetting.js";
 function getHookTypeFromName(name) {
     if (/^get[^a-z]/.test(name)) return "get";
@@ -19,37 +20,57 @@ 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("IdOrParams")) return "get";
+    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, ext, base } = parse(path);
-    if (".ts" !== ext && ".tsx" !== ext && ".js" !== ext && ".jsx" !== ext) return;
-    const serverContent = await readFile(join("shared", path), "utf-8");
-    const match = serverContent.match(new RegExp(`export async function ${name}\\(.+?: (.+?)Params\\)`, "s"));
-    const hasSchema = !!match;
+    const { dir, name, base } = parse(path);
+    if (!isScriptModule(path)) return;
     const upName = name.replace(/^./, (char)=>char.toUpperCase());
     const key = name.replace(/[A-Z]/g, (char)=>`-${char.toLowerCase()}`);
-    const mutationHook = `import { useId } from "react"
+    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 { createRequestFn } from "deepsea-tools"
 
-import { useMutation, UseMutationOptions } from "@tanstack/react-query"
-import { createRequestFn } from "deepsea-tools"
+import { ${name}Action } from "@/actions/${actionImportPath}"
 
-import { ${name}Action } from "@/actions/${join(dir, name)}"
+import { createUse${upName} } from "@/presets/${mutationPresetImportPath}"
 
 export const ${name}Client = createRequestFn(${name}Action)
 
-export interface Use${upName}Params<TOnMutateResult = unknown> extends Omit<
-    UseMutationOptions<Awaited<ReturnType<typeof ${name}Client>>, Error, Parameters<typeof ${name}Client>[0], TOnMutateResult>,
-    "mutationFn"
-> {}
+export const use${upName} = createUse${upName}(${name}Client)
+`;
+    const mutationPreset = `import { useId } from "react"
+
+import { withUseMutationDefaults } from "soda-tanstack-query"
+
+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,
@@ -57,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(/^.+?-/, "")}"] })
@@ -69,29 +88,24 @@ 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"
 
-import { ${name}Action } from "@/actions/${join(dir, name)}"
+import { ${name}Action } from "@/actions/${actionImportPath}"
 
 export const ${name}Client = createRequestFn(${name}Action)
 
-export function ${name}ClientOptional(id?: ${hasSchema ? `${match[1].replace(/Schema$/, "Params").replace(/^./, (char)=>char.toUpperCase())} | ` : ""}undefined | null) {
+export type ${clientInputType} = Parameters<typeof ${name}Client> extends [] ? undefined : Parameters<typeof ${name}Client>[0]
+
+export function ${name}ClientOptional(id?: ${clientInputType} | null) {
     return isNonNullable(id) ? ${name}Client(id) : null
 }
 
@@ -103,7 +117,7 @@ export const use${upName} = createUseQuery({
     const queryHook = `import { createRequestFn } from "deepsea-tools"
 import { createUseQuery } from "soda-tanstack-query"
 
-import { ${name}Action } from "@/actions/${join(dir, name)}"
+import { ${name}Action } from "@/actions/${actionImportPath}"
 
 export const ${name}Client = createRequestFn(${name}Action)
 
@@ -117,49 +131,62 @@ export const use${upName} = createUseQuery({
         query: queryHook,
         mutation: mutationHook
     };
-    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 = 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] = {
-        overwrite,
+        hookPath,
+        mutationPreset,
+        mutationPresetPath,
+        overwrite: hookState.overwrite,
         type: hookType,
         ...map
     };
 }
-async function createActionFromFolder() {
+async function createHookFromFolder() {
     const map = {};
-    async function _createActionFromFolder(dir) {
+    async function _createHookFromFolder(dir) {
         const content = await readdir(dir);
         for (const item of content){
             const path = join(dir, item);
             const stats = await stat(path);
-            if (stats.isDirectory()) await _createActionFromFolder(path);
+            if (stats.isDirectory()) await _createHookFromFolder(path);
             if (stats.isFile()) await createHook(path, map);
         }
     }
-    await _createActionFromFolder("actions");
+    try {
+        await _createHookFromFolder("actions");
+    } catch (error) {
+        if (isNodeError(error) && "ENOENT" === error.code) return map;
+        throw error;
+    }
     return map;
 }
 async function hook(options, { args }) {
-    const map = await createActionFromFolder();
+    const map = await createHookFromFolder();
     const entires = Object.entries(map);
     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);
+    for (const [path, { hookPath, mutationPresetPath, mutationPreset, overwrite, type, ...map }] of newEntires){
+        const resolved = join(root, hookPath);
         const answer = await prompts_select({
             message: path,
             choices: [
@@ -172,25 +199,34 @@ async function hook(options, { args }) {
         });
         setting.hook ??= {};
         setting.hook[resolved] = answer;
-        if ("skip" === answer) continue;
-        const { dir, base } = parse(path);
-        await mkdir(join("hooks", dir), {
-            recursive: true
-        });
-        await writeFile(join("hooks", dir, base.replace(/^./, (char)=>`use${char.toUpperCase()}`)), 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, { overwrite, type, ...map }] of oldEntires){
-        if (!overwrites.includes(path)) continue;
-        const { dir, base } = parse(path);
-        await mkdir(join("hooks", dir), {
-            recursive: true
+    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
         });
-        await writeFile(join("hooks", dir, base.replace(/^./, (char)=>`use${char.toUpperCase()}`)), map[type]);
     }
 }
-export { createActionFromFolder, createHook, hook };
+function isNodeError(error) {
+    return "object" == typeof error && null !== error;
+}
+export { createHook, createHookFromFolder, hook };

package/dist/utils/readSdNextSetting.d.ts

@@ -3,3 +3,6 @@ export interface SdNextSetting {
     hook?: Record<string, OperationType>;
 }
 export declare function readSdNextSetting(): Promise<SdNextSetting>;
+export interface NodeError {
+    code?: string;
+}

package/dist/utils/readSdNextSetting.js

@@ -1,14 +1,19 @@
-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)) {
+    try {
         const setting = JSON.parse(await readFile(settingPath, "utf-8"));
         return setting;
+    } catch (error) {
+        if (isNodeError(error) && "ENOENT" === error.code) return {};
+        console.warn(`Failed to read ${settingPath}, fallback to default setting.`);
+        return {};
     }
-    return {};
+}
+function isNodeError(error) {
+    return "object" == typeof error && null !== error;
 }
 export { readSdNextSetting };

package/dist/utils/runCommand.d.ts

@@ -0,0 +1,7 @@
+import { ChildProcess } from "child_process";
+export interface SpawnCommandParams {
+    args: string[];
+}
+export declare function spawnCommand({ args }: SpawnCommandParams): ChildProcess;
+export declare function runCommand({ args }: SpawnCommandParams): Promise<number>;
+export declare function waitForChild(child: ChildProcess): Promise<number>;

package/dist/utils/runCommand.js

@@ -0,0 +1,25 @@
+import { spawn } from "child_process";
+function spawnCommand({ args }) {
+    const [command, ...commandArgs] = args;
+    return spawn(command, commandArgs, {
+        shell: true,
+        stdio: "inherit"
+    });
+}
+async function runCommand({ args }) {
+    if (0 === args.length) return 0;
+    const child = spawnCommand({
+        args
+    });
+    return waitForChild(child);
+}
+async function waitForChild(child) {
+    return await new Promise((resolve, reject)=>{
+        child.once("error", reject);
+        child.once("close", (code, signal)=>{
+            if ("number" == typeof code) return void resolve(code);
+            resolve(signal ? 1 : 0);
+        });
+    });
+}
+export { runCommand, spawnCommand, waitForChild };

package/dist/utils/sharedArtifact.d.ts

@@ -0,0 +1,23 @@
+export interface SharedModuleInfo {
+    dir: string;
+    ext: string;
+    importPath: string;
+    name: string;
+    relativePath: string;
+}
+export interface GeneratedFileParams {
+    content: string;
+    path: string;
+}
+export interface RemoveGeneratedFileParams {
+    path: string;
+    stopPath?: string;
+}
+export declare const scriptModuleExtensions: string[];
+export declare function normalizePathSeparator(path: string): string;
+export declare function isScriptModule(path: string): boolean;
+export declare function normalizeSharedPath(path: string): string;
+export declare function getSharedModuleInfo(path: string): SharedModuleInfo;
+export declare function toKebabCase(name: string): string;
+export declare function writeGeneratedFile({ content, path }: GeneratedFileParams): Promise<void>;
+export declare function removeGeneratedFile({ path, stopPath }: RemoveGeneratedFileParams): Promise<void>;

package/dist/utils/sharedArtifact.js

@@ -0,0 +1,67 @@
+import { mkdir, readFile, readdir, rm, writeFile } from "fs/promises";
+import { dirname, join, parse, relative } from "path";
+const scriptModuleExtensions = [
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx"
+];
+function normalizePathSeparator(path) {
+    return path.replace(/\\/g, "/");
+}
+function isScriptModule(path) {
+    const { ext } = parse(path);
+    return scriptModuleExtensions.includes(ext);
+}
+function normalizeSharedPath(path) {
+    return normalizePathSeparator(relative("shared", path));
+}
+function getSharedModuleInfo(path) {
+    const relativePath = normalizeSharedPath(path);
+    const { dir, name, ext } = parse(relativePath);
+    return {
+        dir,
+        ext,
+        importPath: normalizePathSeparator(join(dir, name)),
+        name,
+        relativePath
+    };
+}
+function toKebabCase(name) {
+    return name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").toLowerCase();
+}
+async function writeGeneratedFile({ content, path }) {
+    try {
+        const current = await readFile(path, "utf-8");
+        if (current === content) return;
+    } catch (error) {}
+    await mkdir(dirname(path), {
+        recursive: true
+    });
+    await writeFile(path, content);
+}
+async function removeGeneratedFile({ path, stopPath }) {
+    await rm(path, {
+        force: true,
+        recursive: true
+    });
+    if (!stopPath) return;
+    await removeEmptyDirectories(dirname(path), stopPath);
+}
+async function removeEmptyDirectories(path, stopPath) {
+    let currentPath = path;
+    while(currentPath !== stopPath && "." !== currentPath && currentPath !== dirname(currentPath)){
+        try {
+            const content = await readdir(currentPath);
+            if (content.length > 0) return;
+        } catch (error) {
+            return;
+        }
+        await rm(currentPath, {
+            force: true,
+            recursive: true
+        });
+        currentPath = dirname(currentPath);
+    }
+}
+export { getSharedModuleInfo, isScriptModule, normalizePathSeparator, normalizeSharedPath, removeGeneratedFile, scriptModuleExtensions, toKebabCase, writeGeneratedFile };

package/dist/utils/syncSharedArtifacts.d.ts

@@ -0,0 +1,3 @@
+export declare function syncSharedArtifacts(path: string): Promise<void>;
+export declare function removeSharedArtifacts(path: string): Promise<void>;
+export declare function removeSharedArtifactDirectory(path: string): Promise<void>;

package/dist/utils/syncSharedArtifacts.js

@@ -0,0 +1,28 @@
+import { join } from "path";
+import { createAction } from "./createAction.js";
+import { createRoute } from "./createRoute.js";
+import { getSharedModuleInfo, isScriptModule, normalizeSharedPath, removeGeneratedFile } from "./sharedArtifact.js";
+async function syncSharedArtifacts(path) {
+    const info = getSharedModuleInfo(path);
+    if (!isScriptModule(info.relativePath)) return;
+    await createAction(path);
+    await createRoute(path);
+}
+async function removeSharedArtifacts(path) {
+    const info = getSharedModuleInfo(path);
+    if (!isScriptModule(info.relativePath)) return;
+    await removeGeneratedFile({
+        path: join("actions", info.relativePath),
+        stopPath: "actions"
+    });
+    await createRoute();
+}
+async function removeSharedArtifactDirectory(path) {
+    const relativePath = normalizeSharedPath(path);
+    await removeGeneratedFile({
+        path: join("actions", relativePath),
+        stopPath: "actions"
+    });
+    await createRoute();
+}
+export { removeSharedArtifactDirectory, removeSharedArtifacts, syncSharedArtifacts };

package/dist/utils/watch.js

@@ -1,26 +1,10 @@
-import { rm } from "fs/promises";
-import { join, relative } from "path";
 import { watch } from "chokidar";
-import { createAction } from "./createAction.js";
+import { removeSharedArtifactDirectory, removeSharedArtifacts, syncSharedArtifacts } from "./syncSharedArtifacts.js";
 const watcher = watch("shared", {
     awaitWriteFinish: true,
     persistent: true
 });
-watcher.on("add", createAction);
-watcher.on("change", createAction);
-watcher.on("unlink", async (path)=>{
-    path = relative("shared", path).replace(/\\/g, "/");
-    const actionPath = join("actions", path);
-    await rm(actionPath, {
-        recursive: true,
-        force: true
-    });
-});
-watcher.on("unlinkDir", async (path)=>{
-    path = relative("shared", path).replace(/\\/g, "/");
-    const actionPath = join("actions", path);
-    await rm(actionPath, {
-        recursive: true,
-        force: true
-    });
-});
+watcher.on("add", syncSharedArtifacts);
+watcher.on("change", syncSharedArtifacts);
+watcher.on("unlink", removeSharedArtifacts);
+watcher.on("unlinkDir", removeSharedArtifactDirectory);

package/package.json

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

package/src/index.ts

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 
-import { readFileSync } from "fs"
+import { readFile } from "fs/promises"
 import { join } from "path"
+import { fileURLToPath } from "url"
 
 import { Command } from "commander"
 
@@ -11,11 +12,11 @@ import { hook } from "./utils/hook"
 
 const program = new Command()
 
-const path = process.platform === "win32" ? import.meta.resolve("../").replace(/^file:\/\/\//, "") : import.meta.resolve("../").replace(/^file:\/\//, "")
+const path = fileURLToPath(new URL("../", import.meta.url))
 
-const packgeJson = JSON.parse(readFileSync(join(path, "package.json"), "utf-8"))
+const packageJson = JSON.parse(await readFile(join(path, "package.json"), "utf-8"))
 
-program.name("soda next").version(packgeJson.version)
+program.name("soda next").version(packageJson.version)
 
 program.command("build").allowUnknownOption(true).allowExcessArguments(true).action(build)
 

package/src/utils/build.ts

@@ -1,11 +1,10 @@
-import { spawn } from "child_process"
 import { readdir, stat } from "fs/promises"
 import { join } from "path"
 
 import { Command } from "commander"
 
-import { createAction } from "./createAction"
-import { excludeActions } from "./excludeActions"
+import { runCommand } from "./runCommand"
+import { syncSharedArtifacts } from "./syncSharedArtifacts"
 
 export async function buildFolder(dir: string) {
     const content = await readdir(dir)
@@ -15,19 +14,14 @@ export async function buildFolder(dir: string) {
         const stats = await stat(path)
 
         if (stats.isDirectory()) await buildFolder(path)
-        else await createAction(path)
+        else await syncSharedArtifacts(path)
     }
 }
 
 export async function build(options: Record<string, string>, { args }: Command) {
-    await excludeActions()
-
     await buildFolder("shared")
 
     if (args.length === 0) return
 
-    spawn(args.join(" "), {
-        stdio: "inherit",
-        shell: true,
-    })
+    process.exitCode = await runCommand({ args })
 }

package/src/utils/createAction.ts

@@ -1,28 +1,21 @@
-import { mkdir, readFile, writeFile } from "fs/promises"
-import { join, parse, relative } from "path"
+import { join } from "path"
+
+import { getSharedModuleInfo, isScriptModule, writeGeneratedFile } from "./sharedArtifact"
 
 export async function createAction(path: string) {
-    path = relative("shared", path).replace(/\\/g, "/")
-    const { dir, name, ext } = parse(path)
-    if (ext !== ".ts" && ext !== ".tsx" && ext !== ".js" && ext !== ".jsx") return
+    const info = getSharedModuleInfo(path)
+
+    if (!isScriptModule(info.relativePath)) return
 
-    const content = `"use server"
+    await writeGeneratedFile({
+        path: join("actions", info.relativePath),
+        content: `"use server"
 
 import { createResponseFn } from "@/server/createResponseFn"
 
-import { ${name} } from "@/shared/${join(dir, name)}"
+import { ${info.name} } from "@/shared/${info.importPath}"
 
-export const ${name}Action = createResponseFn(${name})
+export const ${info.name}Action = createResponseFn(${info.name})
 `
-
-    const actionPath = join("actions", path)
-
-    try {
-        const current = await readFile(actionPath, "utf-8")
-        if (current === content) return
-    } catch (error) {}
-
-    await mkdir(join("actions", dir), { recursive: true })
-
-    await writeFile(actionPath, content)
+    })
 }