orpc-file-based-router 0.1.4 → 0.1.6

package/README.md

@@ -9,10 +9,6 @@ structure, inspired by Next.js and express-file-routing approaches.
 - 🔄 **Zero Configuration**: Generate routes automatically based on your directory structure
 - ⚡️ **Development Speed**: Eliminate boilerplate code and reduce maintenance overhead
 - 🔍 **Dynamic Routing**: Support for path parameters using `{param}` syntax in file names
-- 📑 **Index Routes**: Support for index routes via `index.ts` files
-
-> ⚠️ **IMPORTANT:** At this time, the plugin's functionality is only guaranteed
-> in nodejs runtime
 
 ## Quickstart
 
@@ -105,31 +101,33 @@ generateRouter(routesDir, outputFile);
 
 ```typescript
 // router.ts
-import { me } from "./routes/auth/me";
-import { signin } from "./routes/auth/signin";
-import { signup } from "./routes/auth/signup";
-import { createPlanet } from "./routes/planets/create";
-import { indexRoute } from "./routes/planets";
-import { listPlanets } from "./routes/planets/list";
-import { findPlanet } from "./routes/planets/{id}/find";
-import { updatePlanet } from "./routes/planets/{id}/update";
-import { sse } from "./routes/sse";
+
+import { me as auth_me__me } from "./routes/auth/me.js"
+import { signin as auth_signin__signin } from "./routes/auth/signin.js"
+import { signup as auth_signup__signup } from "./routes/auth/signup.js"
+import { createPlanet as planets_create__createPlanet } from "./routes/planets/create.js"
+import { indexRoute as planets_index__indexRoute } from "./routes/planets/index.js"
+import { listPlanets as planets_list__listPlanets } from "./routes/planets/list.js"
+import { findPlanet as planets_id_find__findPlanet } from "./routes/planets/{id}/find.js"
+import { updatePlanet as planets_id_update__updatePlanet } from "./routes/planets/{id}/update.js"
+import { sse as sse__sse } from "./routes/sse.js"
 
 export const router = {
   auth: {
-    me: me.route({ path: "/auth/me" }),
-    signin: signin.route({ path: "/auth/signin" }),
-    signup: signup.route({ path: "/auth/signup" }),
+    me: auth_me__me.route({ path: '/auth/me', method: 'GET' }),
+    signin: auth_signin__signin.route({ path: '/auth/signin', method: 'POST' }),
+    signup: auth_signup__signup.route({ path: '/auth/signup', method: 'POST' })
   },
   planets: {
-    create: createPlanet.route({ path: "/planets/create" }),
-    indexRoute: indexRoute.route({ path: "/planets" }),
-    list: listPlanets.route({ path: "/planets/list" }),
-    find: findPlanet.route({ path: "/planets/{id}/find" }),
-    update: updatePlanet.route({ path: "/planets/{id}/update" }),
+    create: planets_create__createPlanet.route({ path: '/planets/create', method: 'POST' }),
+    index: planets_index__indexRoute.route({ path: '/planets', method: 'GET' }),
+    list: planets_list__listPlanets.route({ path: '/planets/list', method: 'GET' }),
+    find: planets_id_find__findPlanet.route({ path: '/planets/{id}/find', method: 'GET' }),
+    update: planets_id_update__updatePlanet.route({ path: '/planets/{id}/update', method: 'PUT' })
   },
-  sse: sse.route({ path: "/sse" }),
-};
+  sse: sse__sse.route({ path: '/sse', method: 'GET' })
+}
+
 
 // lib/orpc.ts
 const client: RouterClient<typeof router> = createORPCClient(link)
@@ -143,8 +141,21 @@ When using `generateRouter`, you can provide additional options to customize the
 | Field              | Type      | Required | Default Value | Description                                                                                                                     |
 |-------------------|----------|--------------|-----------------------|------------------------------------------------------------------------------------------------------------------------------|
 | `importExtension` | string   | false         | `""`(No extension) | File extension to append to import statements in the generated router. Useful when your build setup requires specific extensions. <br>Example: `.js` → `import { me } from "./routes/auth/me.js"` |
+| `enableOpenAPI` | boolean   | false         | `true` | When set to true, each route will be wrapped with OpenAPI .route({ path: '...', method: '...' }) call   |
+| `additionalMethods` | string[]   | false         | `[]` | Additional HTTP methods to recognize from export names.   |
+
 
+## Examples
+### HTTP Method Matching
+If you export functions named e.g. `get`, `post`, `put`, `patch`, `delete/del` etc. from a route file, those will get matched their corresponding http method automatically.
 
+```typescript
+// ./routes/planets.ts
+
+export const get = orpc.handler(async ({ input, context }) => {})
+
+export const post = orpc.handler(async ({ input, context }) => {})
+```
 
 ## 📄 License
 

package/dist/index.cjs

@@ -7,6 +7,25 @@ function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'defau
 
 const path__default = /*#__PURE__*/_interopDefaultCompat(path);
 
+const METHOD_EXPORTS = [
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "HEAD"
+];
+
+const getMethodKey = (method) => {
+  let methodKey = method.toUpperCase();
+  if (methodKey === "DEL") return "DELETE";
+  return methodKey;
+};
+const isMethodExport = (exportName, extraMethods) => {
+  const methods = [...METHOD_EXPORTS, ...extraMethods].map(getMethodKey);
+  return methods.includes(getMethodKey(exportName));
+};
+
 function walkTree(directory, tree = []) {
   const results = [];
   for (const fileName of node_fs.readdirSync(directory)) {
@@ -56,17 +75,28 @@ async function generateRouter(routesDir, outputFile, options) {
   const exports = await generateRoutes(files);
   const importPaths = exports.map((x) => path.relative(path.dirname(outputFile), routesDir).concat(x.path));
   const content = buildRouter(exports, (r, e) => {
-    return `${e}.route({ path: '${r.path.replace(/\/{0,1}index$/, "")}' })`;
+    const alias = routePathToAlias(r.path, e);
+    if (options?.enableOpenAPI ?? true) {
+      const orpcMeta = isORPCProcedure(r.exports[e]) ? r.exports[e]["~orpc"] : void 0;
+      const method = isMethodExport(e, options?.additionalMethods || []) ? getMethodKey(e) : orpcMeta?.route?.method || "POST";
+      const config = { path: r.path.replace(/\/{0,1}index$/, ""), method };
+      return `${alias}.route({ path: '${config.path}', method: '${config.method}' })`;
+    }
+    return alias;
   });
   let routerContent = `// This file is auto-generated
 
 `;
   const extension = options?.importExtension || "";
-  routerContent += importPaths.map((x, i) => `import { ${Object.keys(exports[i].exports).join(", ")} } from "./${x}${extension}"`).join("\n");
+  routerContent += importPaths.map((x, i) => `import { ${Object.keys(exports[i].exports).map((y) => `${y} as ${routePathToAlias(exports[i].path, y)}`).join(", ")} } from "./${x}${extension}"`).join("\n");
   routerContent += "\n\nexport const router = ";
   routerContent += JSON.stringify(content, null, 2).replace(/"/g, "").replace(/(\s*)([a-zA-Z0-9]+-[a-zA-Z0-9-]+):/g, '$1"$2":');
   node_fs.writeFileSync(path.join(outputFile), routerContent);
 }
+function routePathToAlias(routePath, methodName) {
+  const cleanPath = routePath.replace(/\{(\w+)\}/g, "$1").replace(/-/g, "_");
+  return cleanPath.split("/").filter(Boolean).join("_") + "__" + methodName;
+}
 function buildRoutePath(parsedFile) {
   const directory = parsedFile.dir === parsedFile.root ? "" : parsedFile.dir;
   const name = `/${parsedFile.name}`;

package/dist/index.d.cts

@@ -11,6 +11,15 @@ type GeneratorOptions = {
      * @default "" (no extension)
      */
     importExtension?: string;
+    /**
+     * When set to true, each route will be wrapped with OpenAPI .route({ path: '...', method: '...' }) call
+     * @default true
+     */
+    enableOpenAPI?: boolean;
+    /**
+     * Additional HTTP methods to recognize from export names.
+     */
+    additionalMethods?: string[];
 };
 declare function generateRouter(routesDir: string, outputFile: string, options?: GeneratorOptions): Promise<void>;
 type Router = Record<string, any>;

package/dist/index.d.mts

@@ -11,6 +11,15 @@ type GeneratorOptions = {
      * @default "" (no extension)
      */
     importExtension?: string;
+    /**
+     * When set to true, each route will be wrapped with OpenAPI .route({ path: '...', method: '...' }) call
+     * @default true
+     */
+    enableOpenAPI?: boolean;
+    /**
+     * Additional HTTP methods to recognize from export names.
+     */
+    additionalMethods?: string[];
 };
 declare function generateRouter(routesDir: string, outputFile: string, options?: GeneratorOptions): Promise<void>;
 type Router = Record<string, any>;

package/dist/index.d.ts

@@ -11,6 +11,15 @@ type GeneratorOptions = {
      * @default "" (no extension)
      */
     importExtension?: string;
+    /**
+     * When set to true, each route will be wrapped with OpenAPI .route({ path: '...', method: '...' }) call
+     * @default true
+     */
+    enableOpenAPI?: boolean;
+    /**
+     * Additional HTTP methods to recognize from export names.
+     */
+    additionalMethods?: string[];
 };
 declare function generateRouter(routesDir: string, outputFile: string, options?: GeneratorOptions): Promise<void>;
 type Router = Record<string, any>;

package/dist/index.mjs

@@ -1,6 +1,25 @@
 import { writeFileSync, readdirSync, statSync } from 'node:fs';
 import path, { relative, dirname, join } from 'node:path';
 
+const METHOD_EXPORTS = [
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "HEAD"
+];
+
+const getMethodKey = (method) => {
+  let methodKey = method.toUpperCase();
+  if (methodKey === "DEL") return "DELETE";
+  return methodKey;
+};
+const isMethodExport = (exportName, extraMethods) => {
+  const methods = [...METHOD_EXPORTS, ...extraMethods].map(getMethodKey);
+  return methods.includes(getMethodKey(exportName));
+};
+
 function walkTree(directory, tree = []) {
   const results = [];
   for (const fileName of readdirSync(directory)) {
@@ -50,17 +69,28 @@ async function generateRouter(routesDir, outputFile, options) {
   const exports = await generateRoutes(files);
   const importPaths = exports.map((x) => relative(dirname(outputFile), routesDir).concat(x.path));
   const content = buildRouter(exports, (r, e) => {
-    return `${e}.route({ path: '${r.path.replace(/\/{0,1}index$/, "")}' })`;
+    const alias = routePathToAlias(r.path, e);
+    if (options?.enableOpenAPI ?? true) {
+      const orpcMeta = isORPCProcedure(r.exports[e]) ? r.exports[e]["~orpc"] : void 0;
+      const method = isMethodExport(e, options?.additionalMethods || []) ? getMethodKey(e) : orpcMeta?.route?.method || "POST";
+      const config = { path: r.path.replace(/\/{0,1}index$/, ""), method };
+      return `${alias}.route({ path: '${config.path}', method: '${config.method}' })`;
+    }
+    return alias;
   });
   let routerContent = `// This file is auto-generated
 
 `;
   const extension = options?.importExtension || "";
-  routerContent += importPaths.map((x, i) => `import { ${Object.keys(exports[i].exports).join(", ")} } from "./${x}${extension}"`).join("\n");
+  routerContent += importPaths.map((x, i) => `import { ${Object.keys(exports[i].exports).map((y) => `${y} as ${routePathToAlias(exports[i].path, y)}`).join(", ")} } from "./${x}${extension}"`).join("\n");
   routerContent += "\n\nexport const router = ";
   routerContent += JSON.stringify(content, null, 2).replace(/"/g, "").replace(/(\s*)([a-zA-Z0-9]+-[a-zA-Z0-9-]+):/g, '$1"$2":');
   writeFileSync(join(outputFile), routerContent);
 }
+function routePathToAlias(routePath, methodName) {
+  const cleanPath = routePath.replace(/\{(\w+)\}/g, "$1").replace(/-/g, "_");
+  return cleanPath.split("/").filter(Boolean).join("_") + "__" + methodName;
+}
 function buildRoutePath(parsedFile) {
   const directory = parsedFile.dir === parsedFile.root ? "" : parsedFile.dir;
   const name = `/${parsedFile.name}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orpc-file-based-router",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "File-based router plugin for oRPC - automatically generate oRPC router from your file structure",
   "author": "zeeeeby",
   "license": "MIT",