sdnext 0.0.24 → 0.0.26

package/README.md

@@ -1,3 +1,113 @@
 # sdnext
 
-to do.
+`sdnext` 是一个面向 `Next.js` 项目的轻量生成工具，用来基于 `shared/**` 自动生成 `actions/**`、`app/api/actions/**/route.ts`，以及基于 `actions/**` 生成 `hooks/**`。
+
+## 约定
+
+### shared -> action
+
+`shared/addUser.ts`
+
+```ts
+export async function addUser() {}
+```
+
+会生成：
+
+`actions/addUser.ts`
+
+```ts
+"use server"
+
+import { createResponseFn } from "@/server/createResponseFn"
+
+import { addUser } from "@/shared/addUser"
+
+export const addUserAction = createResponseFn(addUser)
+```
+
+### shared -> route
+
+如果源函数显式声明了 `route` 元数据：
+
+```ts
+export async function addUser() {}
+
+addUser.route = true
+```
+
+或：
+
+```ts
+export async function addUser() {}
+
+addUser.route = {}
+```
+
+会额外生成：
+
+`app/api/actions/add-user/route.ts`
+
+```ts
+import { createRoute } from "@/server/createResponseFn"
+
+import { addUser } from "@/shared/addUser"
+
+export const { POST } = createRoute(addUser)
+```
+
+默认情况下，`fn.route` 视为 `false`，不会生成 route。
+
+### actions -> hook
+
+执行 `sdnext hook` 后，会根据 `actions/**` 生成 `hooks/**`。
+
+命名规则：
+
+- `getUser` 默认识别为 `get`
+- `queryUser` 默认识别为 `query`
+- 其他函数默认识别为 `mutation`
+
+## 命令
+
+### build
+
+```bash
+sdnext build next build
+```
+
+执行顺序：
+
+1. 同步生成 `actions/**`
+2. 根据 `fn.route` 同步生成 `app/api/actions/**`
+3. 再执行后续命令
+
+### dev
+
+```bash
+sdnext dev next dev
+```
+
+行为与 `build` 类似，但会额外监听 `shared/**` 的新增、修改、删除，并实时同步生成物。
+
+### hook
+
+```bash
+sdnext hook
+```
+
+扫描 `actions/**` 并交互式生成或覆盖 `hooks/**`。
+
+## 路径映射
+
+- `shared/addUser.ts` -> `actions/addUser.ts`
+- `shared/addUser.ts` -> `app/api/actions/add-user/route.ts`
+- `shared/admin/addUser.ts` -> `actions/admin/addUser.ts`
+- `shared/admin/addUser.ts` -> `app/api/actions/admin/add-user/route.ts`
+
+## 说明
+
+- 只处理 `.ts`、`.tsx`、`.js`、`.jsx`
+- 生成文件会做幂等比较，内容未变化时不会重复写入
+- 删除 `shared` 文件或移除 `fn.route` 后，对应生成物会自动清理
+- `sdnext build` 和 `sdnext dev` 会自动把 `actions/**` 与 `app/api/actions/**` 写入 `.vscode/settings.json` 的 `files.exclude`

package/dist/index.js

@@ -1,15 +1,146 @@
 #!/usr/bin/env node
-import { readFileSync } from "fs";
-import { join } from "path";
-import { Command } from "commander";
-import { build } from "./utils/build.js";
-import { dev } from "./utils/dev.js";
-import { hook } from "./utils/hook.js";
-const program = new Command();
-const path = "win32" === process.platform ? import.meta.resolve("../").replace(/^file:\/\/\//, "") : import.meta.resolve("../").replace(/^file:\/\//, "");
-const packgeJson = JSON.parse(readFileSync(join(path, "package.json"), "utf-8"));
-program.name("soda next").version(packgeJson.version);
-program.command("build").allowUnknownOption(true).allowExcessArguments(true).action(build);
-program.command("dev").allowUnknownOption(true).allowExcessArguments(true).action(dev);
-program.command("hook").action(hook);
-program.parse();
+import * as __WEBPACK_EXTERNAL_MODULE__utils_build_js_f9ba07bf__ from "./utils/build.js";
+import * as __WEBPACK_EXTERNAL_MODULE__utils_dev_js_df994271__ from "./utils/dev.js";
+import * as __WEBPACK_EXTERNAL_MODULE__utils_hook_js_8cbfab27__ from "./utils/hook.js";
+import * as __WEBPACK_EXTERNAL_MODULE_commander__ from "commander";
+import * as __WEBPACK_EXTERNAL_MODULE_fs_promises_400951f8__ from "fs/promises";
+import * as __WEBPACK_EXTERNAL_MODULE_path__ from "path";
+import * as __WEBPACK_EXTERNAL_MODULE_url__ from "url";
+var __webpack_modules__ = {
+    "./src/index.ts": function(module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.a(module, async function(__webpack_handle_async_dependencies__, __webpack_async_result__) {
+            try {
+                __webpack_require__.r(__webpack_exports__);
+                var fs_promises__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("fs/promises");
+                var path__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("path");
+                var url__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("url");
+                var commander__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("commander");
+                var _utils_build__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__("./utils/build");
+                var _utils_dev__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__("./utils/dev");
+                var _utils_hook__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__("./utils/hook");
+                const program = new commander__WEBPACK_IMPORTED_MODULE_3__.Command();
+                const path = (0, url__WEBPACK_IMPORTED_MODULE_2__.fileURLToPath)(new URL("../", import.meta.url));
+                const packageJson = JSON.parse(await (0, fs_promises__WEBPACK_IMPORTED_MODULE_0__.readFile)((0, path__WEBPACK_IMPORTED_MODULE_1__.join)(path, "package.json"), "utf-8"));
+                program.name("soda next").version(packageJson.version);
+                program.command("build").allowUnknownOption(true).allowExcessArguments(true).action(_utils_build__WEBPACK_IMPORTED_MODULE_4__.build);
+                program.command("dev").allowUnknownOption(true).allowExcessArguments(true).action(_utils_dev__WEBPACK_IMPORTED_MODULE_5__.dev);
+                program.command("hook").action(_utils_hook__WEBPACK_IMPORTED_MODULE_6__.hook);
+                program.parse();
+                __webpack_async_result__();
+            } catch (e) {
+                __webpack_async_result__(e);
+            }
+        }, 1);
+    },
+    "./utils/build": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE__utils_build_js_f9ba07bf__;
+    },
+    "./utils/dev": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE__utils_dev_js_df994271__;
+    },
+    "./utils/hook": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE__utils_hook_js_8cbfab27__;
+    },
+    commander: function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_commander__;
+    },
+    "fs/promises": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_fs_promises_400951f8__;
+    },
+    path: function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_path__;
+    },
+    url: function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_url__;
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    var webpackQueues = "function" == typeof Symbol ? Symbol("webpack queues") : "__webpack_queues__";
+    var webpackExports = "function" == typeof Symbol ? Symbol("webpack exports") : "__webpack_exports__";
+    var webpackError = "function" == typeof Symbol ? Symbol("webpack error") : "__webpack_error__";
+    var resolveQueue = (queue)=>{
+        if (queue && queue.d < 1) {
+            queue.d = 1;
+            queue.forEach((fn)=>fn.r--);
+            queue.forEach((fn)=>fn.r-- ? fn.r++ : fn());
+        }
+    };
+    var wrapDeps = (deps)=>deps.map((dep)=>{
+            if (null !== dep && "object" == typeof dep) {
+                if (dep[webpackQueues]) return dep;
+                if (dep.then) {
+                    var queue = [];
+                    queue.d = 0;
+                    dep.then((r)=>{
+                        obj[webpackExports] = r;
+                        resolveQueue(queue);
+                    }, (e)=>{
+                        obj[webpackError] = e;
+                        resolveQueue(queue);
+                    });
+                    var obj = {};
+                    obj[webpackQueues] = (fn)=>fn(queue);
+                    return obj;
+                }
+            }
+            var ret = {};
+            ret[webpackQueues] = function() {};
+            ret[webpackExports] = dep;
+            return ret;
+        });
+    __webpack_require__.a = (module, body, hasAwait)=>{
+        var queue;
+        hasAwait && ((queue = []).d = -1);
+        var depQueues = new Set();
+        var exports = module.exports;
+        var currentDeps;
+        var outerResolve;
+        var reject;
+        var promise = new Promise((resolve, rej)=>{
+            reject = rej;
+            outerResolve = resolve;
+        });
+        promise[webpackExports] = exports;
+        promise[webpackQueues] = (fn)=>{
+            queue && fn(queue), depQueues.forEach(fn), promise["catch"](function() {});
+        };
+        module.exports = promise;
+        body((deps)=>{
+            currentDeps = wrapDeps(deps);
+            var fn;
+            var getResult = ()=>currentDeps.map((d)=>{
+                    if (d[webpackError]) throw d[webpackError];
+                    return d[webpackExports];
+                });
+            var promise = new Promise((resolve)=>{
+                fn = ()=>resolve(getResult);
+                fn.r = 0;
+                var fnQueue = (q)=>q !== queue && !depQueues.has(q) && (depQueues.add(q), q && !q.d && (fn.r++, q.push(fn)));
+                currentDeps.map((dep)=>dep[webpackQueues](fnQueue));
+            });
+            return fn.r ? promise : getResult();
+        }, (err)=>(err ? reject(promise[webpackError] = err) : outerResolve(exports), resolveQueue(queue)));
+        queue && queue.d < 0 && (queue.d = 0);
+    };
+})();
+(()=>{
+    __webpack_require__.r = (exports)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports, '__esModule', {
+            value: true
+        });
+    };
+})();
+__webpack_require__("./src/index.ts");

package/dist/utils/build.js

@@ -1,24 +1,21 @@
-import { spawn } from "child_process";
 import { readdir, stat } from "fs/promises";
 import { join } from "path";
-import { createAction } from "./createAction.js";
-import { excludeActions } from "./excludeActions.js";
+import { runCommand } from "./runCommand.js";
+import { syncSharedArtifacts } from "./syncSharedArtifacts.js";
 async function buildFolder(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 buildFolder(path);
-        else await createAction(path);
+        else await syncSharedArtifacts(path);
     }
 }
 async function build(options, { args }) {
-    await excludeActions();
     await buildFolder("shared");
     if (0 === args.length) return;
-    spawn(args.join(" "), {
-        stdio: "inherit",
-        shell: true
+    process.exitCode = await runCommand({
+        args
     });
 }
 export { build, buildFolder };

package/dist/utils/createAction.js

@@ -1,25 +1,18 @@
-import { mkdir, readFile, writeFile } from "fs/promises";
-import { join, parse, relative } from "path";
+import { join } from "path";
+import { getSharedModuleInfo, isScriptModule, writeGeneratedFile } from "./sharedArtifact.js";
 async function createAction(path) {
-    path = relative("shared", path).replace(/\\/g, "/");
-    const { dir, name, ext } = parse(path);
-    if (".ts" !== ext && ".tsx" !== ext && ".js" !== ext && ".jsx" !== ext) return;
-    const content = `"use server"
+    const info = getSharedModuleInfo(path);
+    if (!isScriptModule(info.relativePath)) return;
+    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})
-`;
-    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
+export const ${info.name}Action = createResponseFn(${info.name})
+`
     });
-    await writeFile(actionPath, content);
 }
 export { createAction };

package/dist/utils/createRoute.d.ts

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,64 @@
+import { readdir } from "fs/promises";
+import { join } from "path";
+import { getSharedModuleInfo, isScriptModule, writeGeneratedFile } from "./sharedArtifact.js";
+async function createRoute(path) {
+    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)
+    });
+}
+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 { 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)
+}
+`;
+}
+export { createRoute };

package/dist/utils/dev.js

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

package/dist/utils/hook.d.ts

@@ -3,9 +3,19 @@ export type HookType = "get" | "query" | "mutation";
 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 createActionFromFolder(): Promise<Record<string, HookData>>;
+export declare function createHookFromFolder(): Promise<Record<string, HookData>>;
 export declare function hook(options: Record<string, string>, { args }: Command): Promise<void>;
+export interface NodeError {
+    code?: string;
+}