sdnext 0.0.23 → 0.0.25

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,34 @@
+import { join } from "path";
+import { createAction } from "./createAction.js";
+import { createRoute } from "./createRoute.js";
+import { getSharedModuleInfo, isScriptModule, normalizeSharedPath, removeGeneratedFile, toKebabCase } 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 removeGeneratedFile({
+        path: join("app", "api", "actions", info.dir, toKebabCase(info.name)),
+        stopPath: join("app", "api", "actions")
+    });
+}
+async function removeSharedArtifactDirectory(path) {
+    const relativePath = normalizeSharedPath(path);
+    await removeGeneratedFile({
+        path: join("actions", relativePath),
+        stopPath: "actions"
+    });
+    await removeGeneratedFile({
+        path: join("app", "api", "actions", relativePath),
+        stopPath: join("app", "api", "actions")
+    });
+}
+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/dist/utils/writeVsCodeSetting.d.ts

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

package/dist/utils/writeVsCodeSetting.js

@@ -9,10 +9,14 @@ async function writeVsCodeSetting(config) {
         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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sdnext",
-  "version": "0.0.23",
+  "version": "0.0.25",
   "description": "",
   "type": "module",
   "exports": {
@@ -41,7 +41,7 @@
     "@inquirer/prompts": "^8.1.0",
     "chokidar": "^5.0.0",
     "commander": "^14.0.2",
-    "deepsea-tools": "5.47.7"
+    "deepsea-tools": "5.47.8"
   },
   "devDependencies": {
     "@types/node": "^24.10.14",

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,11 @@
-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 { excludeGeneratedFiles } from "./excludeGeneratedFiles"
+import { runCommand } from "./runCommand"
+import { syncSharedArtifacts } from "./syncSharedArtifacts"
 
 export async function buildFolder(dir: string) {
     const content = await readdir(dir)
@@ -15,19 +15,16 @@ 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 excludeGeneratedFiles()
 
     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)
+    })
 }

package/src/utils/createRoute.ts

@@ -0,0 +1,44 @@
+import { readFile } from "fs/promises"
+import { join } from "path"
+
+import { getSharedModuleInfo, isScriptModule, removeGeneratedFile, toKebabCase, writeGeneratedFile } from "./sharedArtifact"
+
+export async function createRoute(path: string) {
+    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 })) {
+        await removeGeneratedFile({
+            path: routeDirPath,
+            stopPath: join("app", "api", "actions"),
+        })
+
+        return
+    }
+
+    await writeGeneratedFile({
+        path: routePath,
+        content: `import { createRoute } from "@/server/createResponseFn"
+
+import { ${info.name} } from "@/shared/${info.importPath}"
+
+export const { POST } = createRoute(${info.name})
+`,
+    })
+}
+
+export interface IsRouteEnabledParams {
+    content: string
+    name: string
+}
+
+function isRouteEnabled({ content, name }: IsRouteEnabledParams) {
+    const routeRegExp = new RegExp(`\\b${name}\\.route\\s*=\\s*(true\\b|\\{)`)
+    return routeRegExp.test(content)
+}

package/src/utils/dev.ts

@@ -1,27 +1,44 @@
 import { spawn } from "child_process"
+import { fileURLToPath } from "url"
 
 import { Command } from "commander"
 
 import { buildFolder } from "./build"
-import { excludeActions } from "./excludeActions"
+import { excludeGeneratedFiles } from "./excludeGeneratedFiles"
+import { spawnCommand } from "./runCommand"
 
 export async function dev(options: Record<string, string>, { args }: Command) {
-    await excludeActions()
+    await excludeGeneratedFiles()
 
     await buildFolder("shared")
 
     if (args.length === 0) return
 
-    const watchPath = import.meta.resolve("./watch.js").replace(process.platform === "win32" ? /^file:\/\/\// : /^file:\/\//, "")
+    const watchPath = fileURLToPath(new URL("./watch.js", import.meta.url))
 
-    const child = spawn(process.execPath, [watchPath])
-
-    const child2 = spawn(args.join(" "), {
+    const child = spawn(process.execPath, [watchPath], {
         stdio: "inherit",
-        shell: true,
     })
 
-    child.on("close", () => child2.kill())
+    const child2 = spawnCommand({
+        args,
+    })
+
+    process.exitCode = await new Promise<number>((resolve, reject) => {
+        let settled = false
 
-    child2.on("close", () => child.kill())
+        function onClose(code: number) {
+            if (settled) return
+
+            settled = true
+            child.kill()
+            child2.kill()
+            resolve(code)
+        }
+
+        child.once("error", reject)
+        child2.once("error", reject)
+        child.once("close", (code, signal) => onClose(typeof code === "number" ? code : signal ? 1 : 0))
+        child2.once("close", (code, signal) => onClose(typeof code === "number" ? code : signal ? 1 : 0))
+    })
 }

package/src/utils/{excludeActions.ts → excludeGeneratedFiles.ts}

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

package/src/utils/hook.ts

@@ -1,4 +1,4 @@
-import { mkdir, readdir, readFile, stat, writeFile } from "fs/promises"
+import { readdir, readFile, stat } from "fs/promises"
 import { join, parse, relative } from "path"
 import { cwd } from "process"
 
@@ -6,6 +6,7 @@ import { checkbox, select } from "@inquirer/prompts"
 import { Command } from "commander"
 
 import { readSdNextSetting, SdNextSetting } from "./readSdNextSetting"
+import { isScriptModule, normalizePathSeparator, writeGeneratedFile } from "./sharedArtifact"
 import { writeSdNextSetting } from "./writeSdNextSetting"
 
 export type HookType = "get" | "query" | "mutation"
@@ -32,37 +33,41 @@ 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("IdOrParams")) return "get"
+    if (content.includes("ClientOptional")) return "get"
     if (content.includes("useQuery")) return "query"
     return undefined
 }
 
 export interface HookData extends HookContentMap {
+    hookPath: string
     overwrite: boolean
     type: HookType
 }
 
 export async function createHook(path: string, hookMap: Record<string, HookData>) {
     path = relative("actions", path).replace(/\\/g, "/")
-    const { dir, name, ext, base } = parse(path)
-    if (ext !== ".ts" && ext !== ".tsx" && ext !== ".js" && ext !== ".jsx") 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 actionImportPath = normalizePathSeparator(join(dir, name))
+    const hookName = base.replace(/^./, char => `use${char.toUpperCase()}`)
+    const hookPath = join("hooks", dir, hookName)
+    const clientInputType = `${upName}ClientInput`
 
     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)}"
+import { ${name}Action } from "@/actions/${actionImportPath}"
 
 export const ${name}Client = createRequestFn(${name}Action)
 
+export type ${clientInputType} = Parameters<typeof ${name}Client> extends [] ? void : Parameters<typeof ${name}Client>[0]
+
 export interface Use${upName}Params<TOnMutateResult = unknown> extends Omit<
-    UseMutationOptions<Awaited<ReturnType<typeof ${name}Client>>, Error, Parameters<typeof ${name}Client>[0], TOnMutateResult>,
+    UseMutationOptions<Awaited<ReturnType<typeof ${name}Client>>, Error, ${clientInputType}, TOnMutateResult>,
     "mutationFn"
 > {}
 
@@ -109,11 +114,13 @@ export function use${upName}<TOnMutateResult = unknown>({ onMutate, onSuccess, o
     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
 }
 
@@ -126,7 +133,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)
 
@@ -142,10 +149,6 @@ export const use${upName} = createUseQuery({
         mutation: mutationHook,
     }
 
-    const hookName = base.replace(/^./, char => `use${char.toUpperCase()}`)
-
-    const hookPath = join("hooks", dir, hookName)
-
     let hookType = getHookTypeFromName(name)
     let overwrite = true
 
@@ -160,34 +163,40 @@ export const use${upName} = createUseQuery({
     }
 
     hookMap[path] = {
+        hookPath,
         overwrite,
         type: hookType,
         ...map,
     }
 }
 
-export async function createActionFromFolder() {
+export async function createHookFromFolder() {
     const map: Record<string, HookData> = {}
 
-    async function _createActionFromFolder(dir: string) {
+    async function _createHookFromFolder(dir: string) {
         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) && error.code === "ENOENT") return map
+        throw error
+    }
 
     return map
 }
 
 export async function hook(options: Record<string, string>, { args }: Command) {
-    const map = await createActionFromFolder()
+    const map = await createHookFromFolder()
 
     const entires = Object.entries(map)
 
@@ -204,8 +213,8 @@ export async function hook(options: Record<string, string>, { args }: Command) {
 
     const setting = await getSetting()
 
-    for await (const [path, { overwrite, type, ...map }] of newEntires) {
-        const resolved = join(root, "hooks", path)
+    for (const [path, { hookPath, overwrite, type, ...map }] of newEntires) {
+        const resolved = join(root, hookPath)
 
         const answer = await select<OperationType>({
             message: path,
@@ -218,16 +227,10 @@ export async function hook(options: Record<string, string>, { args }: Command) {
 
         if (answer === "skip") 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],
-        )
+        await writeGeneratedFile({
+            path: hookPath,
+            content: map[answer],
+        })
     }
 
     await writeSdNextSetting(setting)
@@ -237,18 +240,20 @@ export async function hook(options: Record<string, string>, { args }: Command) {
         choices: oldEntires.map(([key]) => key),
     })
 
-    for (const [path, { overwrite, type, ...map }] of oldEntires) {
+    for (const [path, { hookPath, overwrite, type, ...map }] of oldEntires) {
         if (!overwrites.includes(path)) 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[type],
-        )
+        await writeGeneratedFile({
+            path: hookPath,
+            content: map[type],
+        })
     }
 }
+
+export interface NodeError {
+    code?: string
+}
+
+function isNodeError(error: unknown): error is NodeError {
+    return typeof error === "object" && error !== null
+}