rpc4next 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 watanabe-1
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,130 @@
+# rpc4next
+
+Lightweight, type-safe RPC system for Next.js App Router projects.
+
+Inspired by Hono RPC and Pathpida, **rpc4next** automatically generates a type-safe client for your existing `route.ts` **and** `page.tsx` files, enabling seamless server-client communication with full type inference.
+
+---
+
+## ✨ Features
+
+- ✅ 既存の `app/**/route.ts` および `app/**/page.tsx` を活用するため、新たなハンドラファイルの作成は不要
+- ✅ ルート、パラメータ、リクエストボディ、レスポンスの型安全なクライアント生成
+- ✅ 最小限のセットアップで、カスタムサーバー不要
+- ✅ 動的ルート（`[id]`、`[...slug]` など）に対応
+- ✅ CLI による自動クライアント用型定義生成
+
+> **注意**  
+> RPCとしてresponseの戻り値の推論が機能するのは、対象となる `route.ts` の HTTPメソッドハンドラ内で`NextResponse.json()` をしている物のみになります。
+
+---
+
+## 🚀 Getting Started
+
+### 1. Install rpc4next
+
+```bash
+npm install rpc4next
+```
+
+### 2. Define API Routes in Next.js
+
+Next.js プロジェクト内の既存の `app/**/route.ts` と `app/**/page.tsx` ファイルをそのまま利用できます。
+
+```ts
+// app/api/user/[id]/route.ts
+import { NextRequest, NextResponse } from "next/server";
+
+export async function GET(
+  req: NextRequest,
+  segmentData: { params: Promise<{ id: string }> }
+) {
+  const { id } = await segmentData.params;
+  // RPCとしてresponseの戻り値の推論が機能するのは、対象となる `route.ts` の HTTPメソッドハンドラ内で`NextResponse.json()` をしている物のみになります
+  return NextResponse.json({ name: `User ${id}` });
+}
+```
+
+- `GET`、`POST` などのハンドラを定義
+- **RPCとして利用するには、`NextResponse.json()` によるレスポンス返却が必須です**
+
+---
+
+### 3. Generate Type Definitions with CLI
+
+CLI を利用して、Next.js のルート構造から型安全な RPC クライアントの定義を自動生成します。  
+以下のコマンドを実行すると、`route.ts` と `page.tsx` ファイルの両方を走査し、型定義ファイル（outputPathに指定したファイル）が生成されます。
+
+```bash
+npx rpc4next <baseDir> <outputPath>
+```
+
+- `<baseDir>`: Next.js の Appルータが配置されたベースディレクトリ
+- `<outputPath>`: 生成された型定義ファイルの出力先
+
+#### オプション
+
+- **ウォッチモード**  
+  ファイル変更を検知して自動的に再生成する場合は `--watch` オプションを付けます。
+
+  ```bash
+  npx rpc4next <baseDir> <outputPath> --watch
+  ```
+
+- **パラメータ型ファイルの生成**  
+  各ルートに対して個別のパラメータ型定義ファイルを生成する場合は、`--generate-params-types` オプションにファイル名を指定します。
+
+  ```bash
+  npx rpc4next <baseDir> <outputPath> --generate-params-types <paramsFileName>
+  ```
+
+  ※ このオプションを指定する際は、必ずファイル名をセットしてください。ファイル名が指定されない場合、エラーが発生します。
+
+---
+
+### 4. Create Your RPC Client
+
+生成された型定義ファイルを基に、RPC クライアントを作成します。
+
+```ts
+// lib/rpcClient.ts
+import { createClient } from "rpc4next/client";
+import type { PathStructure } from "あなたが生成した型定義ファイル";
+
+export const rpc = createClient<PathStructure>();
+```
+
+---
+
+### 5. Use It in Your Components
+
+コンポーネント内で生成された RPC クライアントを使用します。
+
+```tsx
+// app/page.tsx
+import { rpc } from "@/lib/rpcClient";
+
+export default async function Page() {
+  const res = await rpc.api.user._id("123").$get();
+  const json = await res.json();
+  return <div>{json.name}</div>;
+}
+```
+
+- エディタの補完機能により、利用可能なエンドポイントが自動的に表示されます。
+- リクエストの構造（params, searchParams）はサーバーコードから推論され、レスポンスも型安全に扱えます。
+
+---
+
+## 🚧 Requirements
+
+- Next.js 14+ (App Router 使用)
+- Node.js 18+
+
+---
+
+## 💼 License
+
+MIT
+
+---

package/dist/cli/cache.d.ts

@@ -0,0 +1,4 @@
+export declare const visitedDirsCache: Map<string, boolean>;
+export declare const cntCache: Record<string, number>;
+export declare const clearCntCache: () => void;
+export declare const clearVisitedDirsCacheAbove: (targetPath: string) => void;

package/dist/cli/cache.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearVisitedDirsCacheAbove = exports.clearCntCache = exports.cntCache = exports.visitedDirsCache = void 0;
+const path_1 = __importDefault(require("path"));
+exports.visitedDirsCache = new Map();
+exports.cntCache = {};
+const clearCntCache = () => {
+    Object.keys(exports.cntCache).forEach((key) => delete exports.cntCache[key]);
+};
+exports.clearCntCache = clearCntCache;
+const clearVisitedDirsCacheAbove = (targetPath) => {
+    const basePath = path_1.default.resolve(targetPath);
+    for (const key of exports.visitedDirsCache.keys()) {
+        const normalizedKey = path_1.default.resolve(key);
+        if (normalizedKey === basePath ||
+            basePath.startsWith(normalizedKey + path_1.default.sep)) {
+            exports.visitedDirsCache.delete(key);
+        }
+    }
+};
+exports.clearVisitedDirsCacheAbove = clearVisitedDirsCacheAbove;

package/dist/cli/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/cli.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const chokidar_1 = __importDefault(require("chokidar"));
+const commander_1 = require("commander");
+const cache_1 = require("./cache");
+const debounce_1 = require("./debounce");
+const generate_path_structure_1 = require("./generate-path-structure");
+const program = new commander_1.Command();
+program
+    .description("Generate RPC client type definitions based on the Next.js path structure.")
+    .argument("<baseDir>", "Base directory containing Next.js paths for type generation")
+    .argument("<outputPath>", "Output path for the generated type definitions")
+    .option("-w, --watch", "Watch mode: regenerate on file changes")
+    .option("--generate-params-types [filename]", "Generate params types file with specified filename")
+    .action((baseDir, outputPath, options) => {
+    const resolvedBaseDir = path_1.default.resolve(baseDir).replace(/\\/g, "/");
+    const resolvedOutputPath = path_1.default.resolve(outputPath).replace(/\\/g, "/");
+    const paramsFileName = typeof options.generateParamsTypes === "string"
+        ? options.generateParamsTypes
+        : null;
+    if (options.generateParamsTypes !== undefined && !paramsFileName) {
+        console.error(chalk_1.default.red("Error: --generate-params-types requires a filename (e.g., params.ts) when specified."));
+        process.exit(1);
+    }
+    const log = (msg) => {
+        const time = new Date().toLocaleTimeString();
+        console.log(`${chalk_1.default.gray(`[${time}]`)} ${msg}`);
+    };
+    const generate = () => {
+        log(chalk_1.default.cyan("Generating..."));
+        const { pathStructure: outputContent, paramsTypes } = (0, generate_path_structure_1.generatePages)(resolvedOutputPath, resolvedBaseDir);
+        fs_1.default.writeFileSync(resolvedOutputPath, outputContent);
+        log(chalk_1.default.green(`RPC client type definitions generated at ${resolvedOutputPath}`));
+        if (paramsFileName) {
+            paramsTypes.forEach(({ paramsType, dirPath }) => {
+                const filePath = `${dirPath}/${paramsFileName}`;
+                fs_1.default.writeFileSync(filePath, paramsType);
+            });
+            log(chalk_1.default.green(`Params type files have been generated as '${paramsFileName}' alongside each route/page.`));
+        }
+    };
+    generate();
+    if (options.watch) {
+        log(chalk_1.default.yellow(`Watching ${resolvedBaseDir} for changes...`));
+        const isTargetFiles = (path) => path.endsWith("route.ts") || path.endsWith("page.tsx");
+        const changedPaths = new Set();
+        // Once the debounced function starts executing, no new watcher events will be processed until it completes.
+        // This is due to JavaScript's single-threaded event loop: the current debounced function runs to completion,
+        // and any new change events are queued until the execution finishes.
+        const debouncedGenerate = (0, debounce_1.debounce)(() => {
+            changedPaths.forEach((path) => {
+                (0, cache_1.clearVisitedDirsCacheAbove)(path);
+            });
+            changedPaths.clear();
+            (0, cache_1.clearCntCache)();
+            generate();
+        }, 300);
+        const watcher = chokidar_1.default.watch(resolvedBaseDir, {
+            ignoreInitial: true,
+            // If we exclude everything except files using ignored, the watch mode will terminate, so we added "only files" to the exclusion condition.
+            ignored: (path, stats) => !!(stats === null || stats === void 0 ? void 0 : stats.isFile()) && !isTargetFiles(path),
+        });
+        watcher.on("ready", () => {
+            watcher.on("all", (event, path) => {
+                if (isTargetFiles(path)) {
+                    log(`${chalk_1.default.magenta(`[${event}]`)} ${chalk_1.default.blue(path)}`);
+                    changedPaths.add(path);
+                    debouncedGenerate();
+                }
+            });
+        });
+    }
+});
+program.parse(process.argv);

package/dist/cli/constants.d.ts

@@ -0,0 +1,12 @@
+export declare const END_POINT_FILE_NAMES: readonly ["page.tsx", "route.ts"];
+export declare const QUERY_TYPES: readonly ["Query", "OptionalQuery"];
+export declare const INDENT = "  ";
+export declare const NEWLINE = "\n";
+export declare const STATEMENT_TERMINATOR = ";";
+export declare const TYPE_SEPARATOR = ";";
+export declare const TYPE_END_POINT = "Endpoint";
+export declare const TYPE_KEY_QUERY = "QueryKey";
+export declare const TYPE_KEY_OPTIONAL_QUERY = "OptionalQueryKey";
+export declare const TYPE_KEY_PARAMS = "ParamsKey";
+export declare const TYPE_KEYS: string[];
+export declare const RPC4NEXT_CLIENT_IMPORT_PATH = "rpc4next/client";

package/dist/cli/constants.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RPC4NEXT_CLIENT_IMPORT_PATH = exports.TYPE_KEYS = exports.TYPE_KEY_PARAMS = exports.TYPE_KEY_OPTIONAL_QUERY = exports.TYPE_KEY_QUERY = exports.TYPE_END_POINT = exports.TYPE_SEPARATOR = exports.STATEMENT_TERMINATOR = exports.NEWLINE = exports.INDENT = exports.QUERY_TYPES = exports.END_POINT_FILE_NAMES = void 0;
+exports.END_POINT_FILE_NAMES = ["page.tsx", "route.ts"];
+exports.QUERY_TYPES = ["Query", "OptionalQuery"];
+exports.INDENT = "  ";
+exports.NEWLINE = "\n";
+exports.STATEMENT_TERMINATOR = ";";
+exports.TYPE_SEPARATOR = ";";
+exports.TYPE_END_POINT = "Endpoint";
+exports.TYPE_KEY_QUERY = "QueryKey";
+exports.TYPE_KEY_OPTIONAL_QUERY = "OptionalQueryKey";
+exports.TYPE_KEY_PARAMS = "ParamsKey";
+exports.TYPE_KEYS = [
+    exports.TYPE_END_POINT,
+    exports.TYPE_KEY_OPTIONAL_QUERY,
+    exports.TYPE_KEY_PARAMS,
+    exports.TYPE_KEY_QUERY,
+];
+exports.RPC4NEXT_CLIENT_IMPORT_PATH = "rpc4next/client";

package/dist/cli/debounce.d.ts

@@ -0,0 +1 @@
+export declare const debounce: <T extends (...args: any[]) => void>(func: T, delay: number) => (...args: Parameters<T>) => void;

package/dist/cli/debounce.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debounce = void 0;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const debounce = (func, delay) => {
+    let timer;
+    return (...args) => {
+        clearTimeout(timer);
+        timer = setTimeout(() => {
+            func(...args);
+        }, delay);
+    };
+};
+exports.debounce = debounce;

package/dist/cli/generate-path-structure.d.ts

@@ -0,0 +1,7 @@
+export declare const generatePages: (outputPath: string, baseDir: string) => {
+    pathStructure: string;
+    paramsTypes: {
+        paramsType: string;
+        dirPath: string;
+    }[];
+};

package/dist/cli/generate-path-structure.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePages = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const constants_1 = require("./constants");
+const route_scanner_1 = require("./route-scanner");
+const type_utils_1 = require("./type-utils");
+const generatePages = (outputPath, baseDir) => {
+    const { pathStructure, imports, paramsTypes } = (0, route_scanner_1.scanAppDir)(outputPath, baseDir);
+    const pathStructureType = `export type PathStructure = ${pathStructure}${constants_1.STATEMENT_TERMINATOR}`;
+    const importsStr = imports.length
+        ? `${imports
+            .sort((a, b) => a.path.localeCompare(b.path, undefined, { numeric: true }))
+            .map((v) => v.statement)
+            .join(constants_1.NEWLINE)}`
+        : "";
+    const keyTypes = constants_1.TYPE_KEYS.filter((type) => pathStructure.includes(type));
+    const keyTypesImportStr = (0, type_utils_1.createImport)(keyTypes.join(" ,"), constants_1.RPC4NEXT_CLIENT_IMPORT_PATH);
+    const dirParamsTypes = paramsTypes.map(({ paramsType, path: filePath }) => {
+        const stats = fs_1.default.statSync(filePath);
+        const dirPath = stats.isFile() ? path_1.default.dirname(filePath) : filePath;
+        const params = `export type Params = ${paramsType}${constants_1.STATEMENT_TERMINATOR}`;
+        return {
+            paramsType: params,
+            dirPath,
+        };
+    });
+    return {
+        pathStructure: `${keyTypesImportStr}${constants_1.NEWLINE}${importsStr}${constants_1.NEWLINE}${constants_1.NEWLINE}${pathStructureType}`,
+        paramsTypes: dirParamsTypes,
+    };
+};
+exports.generatePages = generatePages;

package/dist/cli/path-utils.d.ts

@@ -0,0 +1 @@
+export declare const createRelativeImportPath: (outputFile: string, inputFile: string) => string;

package/dist/cli/path-utils.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRelativeImportPath = void 0;
+const path_1 = __importDefault(require("path"));
+const createRelativeImportPath = (outputFile, inputFile) => {
+    let relativePath = path_1.default
+        .relative(path_1.default.dirname(outputFile), inputFile)
+        .replace(/\\/g, "/")
+        .replace(/\.tsx?$/, "");
+    // Add "./" if the file is in the same directory
+    if (!relativePath.startsWith("../")) {
+        relativePath = "./" + relativePath;
+    }
+    return relativePath;
+};
+exports.createRelativeImportPath = createRelativeImportPath;

package/dist/cli/route-scanner.d.ts

@@ -0,0 +1,21 @@
+export declare const hasTargetFiles: (dirPath: string) => boolean;
+export declare const scanAppDir: (output: string, input: string, indent?: string, parentParams?: {
+    paramName: string;
+    routeType: {
+        isDynamic: boolean;
+        isCatchAll: boolean;
+        isOptionalCatchAll: boolean;
+        isGroup: boolean;
+        isParallel: boolean;
+    };
+}[]) => {
+    pathStructure: string;
+    imports: {
+        statement: string;
+        path: string;
+    }[];
+    paramsTypes: {
+        paramsType: string;
+        path: string;
+    }[];
+};

package/dist/cli/route-scanner.js

@@ -0,0 +1,167 @@
+"use strict";
+// Inspired by pathpida (https://github.com/aspida/pathpida)
+// Some parts of this code are based on or adapted from the pathpida project
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanAppDir = exports.hasTargetFiles = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const cache_1 = require("./cache");
+const constants_1 = require("./constants");
+const scan_utils_1 = require("./scan-utils");
+const type_utils_1 = require("./type-utils");
+const constants_2 = require("../lib/constants");
+const endPointFileNames = new Set(constants_1.END_POINT_FILE_NAMES);
+const hasTargetFiles = (dirPath) => {
+    // Return cached result if available
+    if (cache_1.visitedDirsCache.has(dirPath))
+        return cache_1.visitedDirsCache.get(dirPath);
+    const entries = fs_1.default.readdirSync(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+        const { name } = entry;
+        const entryPath = path_1.default.join(dirPath, name);
+        if (name === "node_modules" ||
+            // privete
+            name.startsWith("_") ||
+            // intercepts
+            name.startsWith("(.)") ||
+            name.startsWith("(..)") ||
+            name.startsWith("(...)")) {
+            cache_1.visitedDirsCache.set(dirPath, false);
+            return false;
+        }
+        if (entry.isFile() && endPointFileNames.has(name)) {
+            cache_1.visitedDirsCache.set(dirPath, true);
+            return true;
+        }
+        if (entry.isDirectory()) {
+            if ((0, exports.hasTargetFiles)(entryPath)) {
+                cache_1.visitedDirsCache.set(dirPath, true);
+                return true;
+            }
+        }
+    }
+    cache_1.visitedDirsCache.set(dirPath, false);
+    return false;
+};
+exports.hasTargetFiles = hasTargetFiles;
+const scanAppDir = (output, input, indent = "", parentParams = []) => {
+    indent += constants_1.INDENT;
+    const pathStructures = [];
+    const imports = [];
+    const types = [];
+    const params = [...parentParams];
+    const paramsTypes = [];
+    const entries = fs_1.default
+        .readdirSync(input, { withFileTypes: true })
+        .filter((entry) => {
+        const { name } = entry;
+        if (entry.isDirectory()) {
+            const dirPath = path_1.default.join(input, name);
+            return (0, exports.hasTargetFiles)(dirPath);
+        }
+        return endPointFileNames.has(entry.name);
+    })
+        .sort();
+    entries.forEach((entry) => {
+        const fullPath = path_1.default.join(input, entry.name);
+        const nameWithoutExt = entry.isFile()
+            ? entry.name.replace(/\.[^/.]+$/, "")
+            : entry.name;
+        if (entry.isDirectory()) {
+            const isGroup = nameWithoutExt.startsWith("(") && nameWithoutExt.endsWith(")");
+            const isParallel = nameWithoutExt.startsWith("@");
+            const isOptionalCatchAll = nameWithoutExt.startsWith("[[...") && nameWithoutExt.endsWith("]]");
+            const isCatchAll = nameWithoutExt.startsWith("[...") && nameWithoutExt.endsWith("]");
+            const isDynamic = nameWithoutExt.startsWith("[") && nameWithoutExt.endsWith("]");
+            const { paramName, keyName } = (() => {
+                let param = nameWithoutExt;
+                // Remove []
+                if (isDynamic) {
+                    param = param.replace(/^\[+|\]+$/g, "");
+                }
+                // Remove ...
+                if (isCatchAll || isOptionalCatchAll) {
+                    param = param.replace(/^\.{3}/, "");
+                }
+                const prefix = isOptionalCatchAll
+                    ? constants_2.OPTIONAL_CATCH_ALL_PREFIX
+                    : isCatchAll
+                        ? constants_2.CATCH_ALL_PREFIX
+                        : isDynamic
+                            ? constants_2.DYNAMIC_PREFIX
+                            : "";
+                return { paramName: param, keyName: `${prefix}${param}` };
+            })();
+            if (isDynamic || isCatchAll || isOptionalCatchAll) {
+                const routeType = {
+                    isGroup,
+                    isParallel,
+                    isOptionalCatchAll,
+                    isCatchAll,
+                    isDynamic,
+                };
+                params.push({ paramName, routeType });
+            }
+            const isSkipDir = isGroup || isParallel;
+            const { pathStructure: childPathStructure, imports: childImports, paramsTypes: childParamsTypes, } = (0, exports.scanAppDir)(output, fullPath, isSkipDir ? indent.replace(constants_1.INDENT, "") : indent, [...params]);
+            imports.push(...childImports);
+            paramsTypes.push(...childParamsTypes);
+            if (isSkipDir) {
+                // Extract the contents inside {}
+                const match = childPathStructure.match(/^\s*\{([\s\S]*)\}\s*$/);
+                const childStr = match ? match[1].trim() : null;
+                if (childStr) {
+                    pathStructures.push(`${indent}${childStr}`);
+                }
+            }
+            else {
+                pathStructures.push(`${indent}"${keyName}": ${childPathStructure}`);
+            }
+        }
+        else {
+            const queryDef = (0, scan_utils_1.scanQuery)(output, fullPath);
+            if (queryDef) {
+                const { importStatement: statement, importPath: path, type } = queryDef;
+                imports.push({ statement, path });
+                types.push(type);
+            }
+            constants_2.HTTP_METHODS_EXCLUDE_OPTIONS.forEach((method) => {
+                const routeDef = (0, scan_utils_1.scanRoute)(output, fullPath, method);
+                if (routeDef) {
+                    const { importStatement: statement, importPath: path, type, } = routeDef;
+                    imports.push({ statement, path });
+                    types.push(type);
+                }
+            });
+            types.push(constants_1.TYPE_END_POINT);
+            if (params.length > 0) {
+                const fields = params.map((param) => {
+                    const { paramName, routeType } = param;
+                    const { isCatchAll, isOptionalCatchAll } = routeType;
+                    const paramType = isCatchAll
+                        ? "string[]"
+                        : isOptionalCatchAll
+                            ? "string[] | undefined"
+                            : "string";
+                    return { name: paramName, type: paramType };
+                });
+                const paramsType = (0, type_utils_1.createObjectType)(fields);
+                paramsTypes.push({ paramsType, path: fullPath.replace(/\\/g, "/") });
+                types.push((0, type_utils_1.createRecodeType)(constants_1.TYPE_KEY_PARAMS, paramsType));
+            }
+        }
+    });
+    const typeString = types.join(" & ");
+    const pathStructure = pathStructures.length > 0
+        ? `${typeString}${typeString ? " & " : ""}{${constants_1.NEWLINE}${pathStructures.join(`,${constants_1.NEWLINE}`)}${constants_1.NEWLINE}${indent.replace(constants_1.INDENT, "")}}`
+        : typeString;
+    return {
+        pathStructure,
+        imports,
+        paramsTypes,
+    };
+};
+exports.scanAppDir = scanAppDir;

package/dist/cli/scan-utils.d.ts

@@ -0,0 +1,20 @@
+import { HttpMethod } from "../lib/types";
+export declare const createImportAlias: (type: string, key: string) => string;
+export declare const scanFile: <T extends string | undefined>(outputFile: string, inputFile: string, findCallBack: (fileContents: string) => T, typeCallBack: (type: NonNullable<T>, importAlias: string) => string) => {
+    importName: string;
+    importPath: string;
+    importStatement: string;
+    type: string;
+} | undefined;
+export declare const scanQuery: (outputFile: string, inputFile: string) => {
+    importName: string;
+    importPath: string;
+    importStatement: string;
+    type: string;
+} | undefined;
+export declare const scanRoute: (outputFile: string, inputFile: string, httpMethod: HttpMethod) => {
+    importName: string;
+    importPath: string;
+    importStatement: string;
+    type: string;
+} | undefined;

package/dist/cli/scan-utils.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanRoute = exports.scanQuery = exports.scanFile = exports.createImportAlias = void 0;
+const fs_1 = __importDefault(require("fs"));
+const cache_1 = require("./cache");
+const constants_1 = require("./constants");
+const path_utils_1 = require("./path-utils");
+const type_utils_1 = require("./type-utils");
+// 連番付与
+const createImportAlias = (type, key) => {
+    if (!cache_1.cntCache[key]) {
+        cache_1.cntCache[key] = 0;
+    }
+    return `${type}_${cache_1.cntCache[key]++}`;
+};
+exports.createImportAlias = createImportAlias;
+const scanFile = (outputFile, inputFile, findCallBack, typeCallBack) => {
+    const fileContents = fs_1.default.readFileSync(inputFile, "utf8");
+    const type = findCallBack(fileContents);
+    if (!type)
+        return;
+    const relativeImportPath = (0, path_utils_1.createRelativeImportPath)(outputFile, inputFile);
+    const importAlias = (0, exports.createImportAlias)(type, type);
+    return {
+        importName: importAlias,
+        importPath: relativeImportPath,
+        importStatement: (0, type_utils_1.createImport)(type, relativeImportPath, importAlias),
+        type: typeCallBack(type, importAlias),
+    };
+};
+exports.scanFile = scanFile;
+// query定義作成
+const scanQuery = (outputFile, inputFile) => {
+    return (0, exports.scanFile)(outputFile, inputFile, (fileContents) => {
+        return constants_1.QUERY_TYPES.find((type) => new RegExp(`export (interface ${type} ?{|type ${type} ?=)`).test(fileContents));
+    }, (type, importAlias) => type === "Query"
+        ? (0, type_utils_1.createRecodeType)(constants_1.TYPE_KEY_QUERY, importAlias)
+        : (0, type_utils_1.createRecodeType)(constants_1.TYPE_KEY_OPTIONAL_QUERY, importAlias));
+};
+exports.scanQuery = scanQuery;
+// route定義作成
+const scanRoute = (outputFile, inputFile, httpMethod) => {
+    return (0, exports.scanFile)(outputFile, inputFile, (fileContents) => {
+        return [httpMethod].find((method) => new RegExp(`export (async )?(function ${method} ?\\(|const ${method} ?=|\\{[^}]*\\b${method}\\b[^}]*\\} ?=|const \\{[^}]*\\b${method}\\b[^}]*\\} ?=|\\{[^}]*\\b${method}\\b[^}]*\\} from)`).test(fileContents));
+    }, (type, importAlias) => (0, type_utils_1.createObjectType)([
+        { name: `$${type.toLowerCase()}`, type: `typeof ${importAlias}` },
+    ]));
+};
+exports.scanRoute = scanRoute;

package/dist/cli/type-utils.d.ts

@@ -0,0 +1,6 @@
+export declare const createRecodeType: (key: string, value: string) => string;
+export declare const createObjectType: (fields: {
+    name: string;
+    type: string;
+}[]) => string;
+export declare const createImport: (type: string, path: string, importAlias?: string) => string;