sdnext 0.0.25 → 0.0.27

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/createAction.js

@@ -1,15 +1,19 @@
 import { join } from "path";
+import { resolveProjectImportPath } from "./resolveProjectImportPath.js";
 import { getSharedModuleInfo, isScriptModule, writeGeneratedFile } from "./sharedArtifact.js";
 async function createAction(path) {
     const info = getSharedModuleInfo(path);
     if (!isScriptModule(info.relativePath)) return;
+    const actionPath = join("actions", info.relativePath);
+    const createResponseFnImportPath = await resolveProjectImportPath(actionPath, "server/createResponseFn");
+    const sharedImportPath = await resolveProjectImportPath(actionPath, `shared/${info.importPath}`);
     await writeGeneratedFile({
-        path: join("actions", info.relativePath),
+        path: actionPath,
         content: `"use server"
 
-import { createResponseFn } from "@/server/createResponseFn"
+import { createResponseFn } from "${createResponseFnImportPath}"
 
-import { ${info.name} } from "@/shared/${info.importPath}"
+import { ${info.name} } from "${sharedImportPath}"
 
 export const ${info.name}Action = createResponseFn(${info.name})
 `

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,70 @@
-import { readFile } from "fs/promises";
+import { readdir } from "fs/promises";
 import { join } from "path";
-import { getSharedModuleInfo, isScriptModule, removeGeneratedFile, toKebabCase, writeGeneratedFile } from "./sharedArtifact.js";
+import { resolveProjectImportPath } from "./resolveProjectImportPath.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");
+    const routePath = join("app", "api", "action", "[...action]", "route.ts");
     await writeGeneratedFile({
         path: routePath,
-        content: `import { createRoute } from "@/server/createResponseFn"
+        content: await getRouteFileContent(modules, routePath)
+    });
+}
+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;
+}
+async function getRouteFileContent(items, routePath) {
+    const createRouteFnImportPath = await resolveProjectImportPath(routePath, "server/createResponseFn");
+    const importLines = (await Promise.all(items.map(async (item)=>{
+        const importPath = await resolveProjectImportPath(routePath, `shared/${item.importPath}`);
+        return `import { ${item.name} } from "${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 "${createRouteFnImportPath}"
+${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

@@ -3,6 +3,7 @@ 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 { resolveProjectImportPath } from "./resolveProjectImportPath.js";
 import { isScriptModule, normalizePathSeparator, writeGeneratedFile } from "./sharedArtifact.js";
 import { writeSdNextSetting } from "./writeSdNextSetting.js";
 function getHookTypeFromName(name) {
@@ -20,9 +21,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") && /from\s+["'][^"']*\/presets\//.test(content)) 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 +48,34 @@ 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"
+    const actionPath = normalizePathSeparator(join("actions", actionImportPath));
+    const hookActionImportPath = await resolveProjectImportPath(hookPath, actionPath);
+    const hookPresetImportPath = await resolveProjectImportPath(hookPath, normalizePathSeparator(join("presets", mutationPresetImportPath)));
+    const mutationPresetSharedImportPath = await resolveProjectImportPath(mutationPresetPath, normalizePathSeparator(join("shared", actionImportPath)));
+    const mutationHook = `import { createRequestFn } from "deepsea-tools"
 
-import { useMutation, UseMutationOptions } from "@tanstack/react-query"
-import { createRequestFn } from "deepsea-tools"
+import { ${name}Action } from "${hookActionImportPath}"
 
-import { ${name}Action } from "@/actions/${actionImportPath}"
+import { createUse${upName} } from "${hookPresetImportPath}"
 
 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 "${mutationPresetSharedImportPath}"
 
-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,
@@ -61,8 +83,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,25 +93,18 @@ 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/${actionImportPath}"
+import { ${name}Action } from "${hookActionImportPath}"
 
 export const ${name}Client = createRequestFn(${name}Action)
 
@@ -109,7 +122,7 @@ export const use${upName} = createUseQuery({
     const queryHook = `import { createRequestFn } from "deepsea-tools"
 import { createUseQuery } from "soda-tanstack-query"
 
-import { ${name}Action } from "@/actions/${actionImportPath}"
+import { ${name}Action } from "${hookActionImportPath}"
 
 export const ${name}Client = createRequestFn(${name}Action)
 
@@ -124,19 +137,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 +190,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 +204,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/resolveProjectImportPath.d.ts

@@ -0,0 +1 @@
+export declare function resolveProjectImportPath(fromPath: string, targetPath: string): Promise<string>;

package/dist/utils/resolveProjectImportPath.js

@@ -0,0 +1,201 @@
+import { constants } from "node:fs";
+import { access, readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { dirname, isAbsolute, join, normalize, relative, resolve } from "node:path";
+import { cwd } from "node:process";
+import { normalizePathSeparator } from "./sharedArtifact.js";
+const resolveProjectImportPath_require = createRequire(import.meta.url);
+const projectRoot = cwd();
+let rootAliasPromise;
+async function resolveProjectImportPath(fromPath, targetPath) {
+    const normalizedTargetPath = normalizePathSeparator(targetPath).replace(/^\.?\//, "");
+    const rootAlias = await getProjectRootAlias();
+    if (rootAlias) return `${rootAlias}/${normalizedTargetPath}`;
+    return getRelativeImportPath(fromPath, normalizedTargetPath);
+}
+function getRelativeImportPath(fromPath, targetPath) {
+    const fromDir = dirname(fromPath);
+    let importPath = normalizePathSeparator(relative(fromDir, targetPath));
+    if (!importPath.startsWith(".")) importPath = `./${importPath}`;
+    return importPath;
+}
+async function getProjectRootAlias() {
+    rootAliasPromise ??= resolveProjectRootAlias();
+    return rootAliasPromise;
+}
+async function resolveProjectRootAlias() {
+    const configPath = await findProjectConfigPath(projectRoot);
+    if (!configPath) return;
+    return readRootAliasFromConfig(configPath, new Set());
+}
+async function findProjectConfigPath(path) {
+    const candidates = [
+        join(path, "tsconfig.json"),
+        join(path, "jsconfig.json")
+    ];
+    for (const candidate of candidates)if (await exists(candidate)) return candidate;
+}
+async function readRootAliasFromConfig(configPath, seen) {
+    const normalizedPath = normalize(configPath);
+    if (seen.has(normalizedPath)) return;
+    seen.add(normalizedPath);
+    const config = await readJsonConfig(configPath);
+    const compilerOptions = toObject(config.compilerOptions);
+    const configDir = dirname(configPath);
+    const baseDir = getBaseDir(configDir, compilerOptions.baseUrl);
+    const paths = toPathMap(compilerOptions.paths);
+    if (paths) {
+        const rootAlias = findRootAlias(paths, baseDir, projectRoot);
+        if (rootAlias) return rootAlias;
+    }
+    const extendsValue = "string" == typeof config.extends ? config.extends : void 0;
+    if (!extendsValue) return;
+    const extendsPath = await resolveExtendsPath(extendsValue, configDir);
+    if (!extendsPath) return;
+    return readRootAliasFromConfig(extendsPath, seen);
+}
+function getBaseDir(configDir, baseUrl) {
+    if ("string" != typeof baseUrl) return configDir;
+    return resolve(configDir, baseUrl);
+}
+function findRootAlias(paths, baseDir, rootDir) {
+    for (const [key, targets] of Object.entries(paths)){
+        const alias = getAliasName(key);
+        if (alias) {
+            for (const target of targets)if (isRootTarget(target, baseDir, rootDir)) return alias;
+        }
+    }
+}
+function getAliasName(pattern) {
+    const wildcard = splitWildcard(pattern);
+    if (!wildcard || wildcard.suffix.length > 0) return;
+    const aliasPrefix = wildcard.prefix.replace(/\/$/, "");
+    if (!aliasPrefix) return;
+    return aliasPrefix;
+}
+function isRootTarget(pattern, baseDir, rootDir) {
+    const wildcard = splitWildcard(pattern);
+    if (!wildcard || wildcard.suffix.length > 0) return false;
+    const targetPath = resolve(baseDir, wildcard.prefix || ".");
+    return normalizeForComparison(targetPath) === normalizeForComparison(rootDir);
+}
+function splitWildcard(value) {
+    const index = value.indexOf("*");
+    if (index < 0) return;
+    if (value.indexOf("*", index + 1) >= 0) return;
+    return {
+        prefix: value.slice(0, index),
+        suffix: value.slice(index + 1)
+    };
+}
+async function resolveExtendsPath(extendsValue, baseDir) {
+    if (isAbsolute(extendsValue) || extendsValue.startsWith(".")) {
+        const relativeCandidates = getRelativeCandidates(resolve(baseDir, extendsValue));
+        for (const candidate of relativeCandidates)if (await exists(candidate)) return candidate;
+        return;
+    }
+    const moduleCandidates = getModuleCandidates(extendsValue);
+    for (const candidate of moduleCandidates)try {
+        return resolveProjectImportPath_require.resolve(candidate, {
+            paths: [
+                baseDir
+            ]
+        });
+    } catch (error) {}
+}
+function getRelativeCandidates(path) {
+    if (path.endsWith(".json")) return [
+        path
+    ];
+    return [
+        path,
+        `${path}.json`
+    ];
+}
+function getModuleCandidates(path) {
+    if (path.endsWith(".json")) return [
+        path
+    ];
+    return [
+        path,
+        `${path}.json`
+    ];
+}
+async function readJsonConfig(path) {
+    const content = await readFile(path, "utf-8");
+    const parsed = JSON.parse(stripTrailingCommas(stripComments(content)));
+    return toObject(parsed);
+}
+function stripComments(content) {
+    const output = [];
+    let inString = false;
+    let escaped = false;
+    for(let index = 0; index < content.length; index++){
+        const char = content[index];
+        const next = content[index + 1];
+        if (inString) {
+            output.push(char);
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if ("\\" === char) {
+                escaped = true;
+                continue;
+            }
+            if ("\"" === char) inString = false;
+            continue;
+        }
+        if ("\"" === char) {
+            inString = true;
+            output.push(char);
+            continue;
+        }
+        if ("/" === char && "/" === next) {
+            while(index < content.length && "\n" !== content[index])index++;
+            output.push("\n");
+            continue;
+        }
+        if ("/" === char && "*" === next) {
+            index += 2;
+            while(index < content.length && !("*" === content[index] && "/" === content[index + 1]))index++;
+            index++;
+            continue;
+        }
+        output.push(char);
+    }
+    return output.join("").replace(/^\uFEFF/, "");
+}
+function stripTrailingCommas(content) {
+    return content.replace(/,\s*([}\]])/g, "$1");
+}
+function toPathMap(value) {
+    if (!value || "object" != typeof value || Array.isArray(value)) return;
+    const entries = [];
+    for (const [key, item] of Object.entries(value)){
+        if (!Array.isArray(item)) continue;
+        const list = item.filter((target)=>"string" == typeof target);
+        if (0 !== list.length) entries.push([
+            key,
+            list
+        ]);
+    }
+    if (0 === entries.length) return;
+    return Object.fromEntries(entries);
+}
+function toObject(value) {
+    if (value && "object" == typeof value && !Array.isArray(value)) return value;
+    return {};
+}
+async function exists(path) {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    } catch (error) {
+        return false;
+    }
+}
+function normalizeForComparison(path) {
+    return normalize(path).replace(/\\/g, "/").replace(/\/$/, "").toLowerCase();
+}
+export { resolveProjectImportPath };

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.27",
   "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