elysia-autoload 0.1.9 → 0.2.1

package/README.md

@@ -1,164 +1,164 @@
-# elysia-autoload
-
-Plugin for [Elysia](https://elysiajs.com/) which autoload all routes in directory and code-generate types for [Eden](https://elysiajs.com/eden/overview.html)
-
-**Currently, Eden types generation is broken!!**
-
-## Installation
-
-### Start new project with [create-elysiajs](https://github.com/kravetsone/create-elysiajs)
-
-```bash
-bun create elysiajs <directory-name>
-```
-
-and select `Autoload` in plugins
-
-### Manual
-
-```bash
-bun install elysia-autoload
-```
-
-## Usage
-
-## Register the plugin
-
-```ts
-import { Elysia } from "elysia";
-import { autoload } from "elysia-autoload";
-
-const app = new Elysia().use(autoload()).listen(3000);
-
-export type ElysiaApp = typeof app;
-```
-
-## Create route
-
-```ts
-// routes/index.ts
-import type { ElysiaApp } from "app";
-
-export default (app: ElysiaApp) => app.get("/", { hello: "world" });
-```
-
-### Directory structure
-
-Guide how `elysia-autoload` match routes
-
-```
-├── app.ts
-├── routes
-    ├── index.ts // index routes
-    ├── posts
-        ├── index.ts
-        └── [id].ts // dynamic params
-    ├── likes
-        └── [...].ts // wildcard
-    ├── domains
-        ├── @[...] // wildcard with @ prefix
-            └──index.ts
-    ├── frontend
-        └──index.tsx // usage of tsx extension
-    └── users.ts
-└── package.json
-```
-
--   /routes/index.ts → /
--   /routes/posts/index.ts → /posts
--   /routes/posts/[id].ts → /posts/:id
--   /routes/users.ts → /users
--   /routes/likes/[...].ts → /likes/\*
--   /routes/domains/@[...]/index.ts → /domains/@\*
--   /routes/frontend/index.tsx → /frontend
-
-## Options
-
-| Key      | Type                                       | Default                            | Description                                                                         |
-| -------- | ------------------------------------------ | ---------------------------------- | ----------------------------------------------------------------------------------- |
-| pattern? | string                                     | "\*\*\/\*.{ts,tsx,js,jsx,mjs,cjs}" | [Glob patterns](<https://en.wikipedia.org/wiki/Glob_(programming)>)                 |
-| dir?     | string                                     | "./routes"                         | The folder where routes are located                                                 |
-| prefix?  | string                                     |                                    | Prefix for routes                                                                   |
-| types?   | boolean \| [Types Options](#types-options) | false                              | Options to configure type code-generation. if boolean - enables/disables generation |
-| schema?  | Function                                   |                                    | Handler for providing routes guard schema                                           |
-
-### Types Options
-
-| Key        | Type               | Default             | Description                                                                             |
-| ---------- | ------------------ | ------------------- | --------------------------------------------------------------------------------------- |
-| output?    | string \| string[] | "./routes-types.ts" | Type code-generation output. It can be an array                                         |
-| typeName?  | string             | "Routes"            | Name for code-generated global type for [Eden](https://elysiajs.com/eden/overview.html) |
-| useExport? | boolean            | false               | Use export instead of global type                                                       |
-
-### Usage of types code-generation for [Eden](https://elysiajs.com/eden/overview.html)
-
-```ts
-// app.ts
-import { Elysia } from "elysia";
-import { autoload } from "elysia-autoload";
-
-const app = new Elysia()
-    .use(
-        autoload({
-            types: {
-                output: "./routes.ts",
-                typeName: "Routes",
-            }, // or pass true for use default params
-        })
-    )
-    .listen(3000);
-
-export type ElysiaApp = typeof app;
-```
-
-```ts
-// client.ts
-
-import { edenTreaty } from "@elysiajs/eden";
-
-// Routes are a global type so you don't need to import it.
-
-const app = edenTreaty<Routes>("http://localhost:3002");
-
-const { data } = await app.test["some-path-param"].get({
-    $query: {
-        key: 2,
-    },
-});
-
-console.log(data);
-```
-
-Example of app with types code-generation you can see in [example](https://github.com/kravetsone/elysia-autoload/tree/main/example)
-
-### Usage of schema handler
-
-```ts
-import swagger from "@elysiajs/swagger";
-import Elysia from "elysia";
-import { autoload } from "elysia-autoload";
-
-const app = new Elysia()
-    .use(
-        autoload({
-            schema: ({ path, url }) => {
-                const tag = url.split("/").at(1)!;
-
-                return {
-                    beforeHandle: ({ request }) => {
-                        console.log(request.url);
-                    },
-                    detail: {
-                        description: `Route autoloaded from ${path}`,
-                        tags: [tag],
-                    },
-                };
-            },
-        })
-    )
-    .use(swagger());
-
-export type ElysiaApp = typeof app;
-
-app.listen(3001, console.log);
-```
+# elysia-autoload
+
+Plugin for [Elysia](https://elysiajs.com/) which autoload all routes in directory and code-generate types for [Eden](https://elysiajs.com/eden/overview.html)
+
+**Currently, Eden types generation is broken!!**
+
+## Installation
+
+### Start new project with [create-elysiajs](https://github.com/kravetsone/create-elysiajs)
+
+```bash
+bun create elysiajs <directory-name>
+```
+
+and select `Autoload` in plugins
+
+### Manual
+
+```bash
+bun install elysia-autoload
+```
+
+## Usage
+
+## Register the plugin
+
+```ts
+import { Elysia } from "elysia";
+import { autoload } from "elysia-autoload";
+
+const app = new Elysia().use(autoload()).listen(3000);
+
+export type ElysiaApp = typeof app;
+```
+
+## Create route
+
+```ts
+// routes/index.ts
+import type { ElysiaApp } from "app";
+
+export default (app: ElysiaApp) => app.get("/", { hello: "world" });
+```
+
+### Directory structure
+
+Guide how `elysia-autoload` match routes
+
+```
+├── app.ts
+├── routes
+    ├── index.ts // index routes
+    ├── posts
+        ├── index.ts
+        └── [id].ts // dynamic params
+    ├── likes
+        └── [...].ts // wildcard
+    ├── domains
+        ├── @[...] // wildcard with @ prefix
+            └──index.ts
+    ├── frontend
+        └──index.tsx // usage of tsx extension
+    └── users.ts
+└── package.json
+```
+
+-   /routes/index.ts → /
+-   /routes/posts/index.ts → /posts
+-   /routes/posts/[id].ts → /posts/:id
+-   /routes/users.ts → /users
+-   /routes/likes/[...].ts → /likes/\*
+-   /routes/domains/@[...]/index.ts → /domains/@\*
+-   /routes/frontend/index.tsx → /frontend
+
+## Options
+
+| Key      | Type                                       | Default                            | Description                                                                         |
+| -------- | ------------------------------------------ | ---------------------------------- | ----------------------------------------------------------------------------------- |
+| pattern? | string                                     | "\*\*\/\*.{ts,tsx,js,jsx,mjs,cjs}" | [Glob patterns](<https://en.wikipedia.org/wiki/Glob_(programming)>)                 |
+| dir?     | string                                     | "./routes"                         | The folder where routes are located                                                 |
+| prefix?  | string                                     |                                    | Prefix for routes                                                                   |
+| types?   | boolean \| [Types Options](#types-options) | false                              | Options to configure type code-generation. if boolean - enables/disables generation |
+| schema?  | Function                                   |                                    | Handler for providing routes guard schema                                           |
+
+### Types Options
+
+| Key        | Type               | Default             | Description                                                                             |
+| ---------- | ------------------ | ------------------- | --------------------------------------------------------------------------------------- |
+| output?    | string \| string[] | "./routes-types.ts" | Type code-generation output. It can be an array                                         |
+| typeName?  | string             | "Routes"            | Name for code-generated global type for [Eden](https://elysiajs.com/eden/overview.html) |
+| useExport? | boolean            | false               | Use export instead of global type                                                       |
+
+### Usage of types code-generation for [Eden](https://elysiajs.com/eden/overview.html)
+
+```ts
+// app.ts
+import { Elysia } from "elysia";
+import { autoload } from "elysia-autoload";
+
+const app = new Elysia()
+    .use(
+        autoload({
+            types: {
+                output: "./routes.ts",
+                typeName: "Routes",
+            }, // or pass true for use default params
+        })
+    )
+    .listen(3000);
+
+export type ElysiaApp = typeof app;
+```
+
+```ts
+// client.ts
+
+import { edenTreaty } from "@elysiajs/eden";
+
+// Routes are a global type so you don't need to import it.
+
+const app = edenTreaty<Routes>("http://localhost:3002");
+
+const { data } = await app.test["some-path-param"].get({
+    $query: {
+        key: 2,
+    },
+});
+
+console.log(data);
+```
+
+Example of app with types code-generation you can see in [example](https://github.com/kravetsone/elysia-autoload/tree/main/example)
+
+### Usage of schema handler
+
+```ts
+import swagger from "@elysiajs/swagger";
+import Elysia from "elysia";
+import { autoload } from "elysia-autoload";
+
+const app = new Elysia()
+    .use(
+        autoload({
+            schema: ({ path, url }) => {
+                const tag = url.split("/").at(1)!;
+
+                return {
+                    beforeHandle: ({ request }) => {
+                        console.log(request.url);
+                    },
+                    detail: {
+                        description: `Route autoloaded from ${path}`,
+                        tags: [tag],
+                    },
+                };
+            },
+        })
+    )
+    .use(swagger());
+
+export type ElysiaApp = typeof app;
+
+app.listen(3001, console.log);
+```

package/dist/index.cjs

@@ -0,0 +1,144 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  autoload: () => autoload
+});
+module.exports = __toCommonJS(src_exports);
+var import_node_fs = require("fs");
+var import_node_path2 = require("path");
+var import_elysia = require("elysia");
+
+// src/utils.ts
+var import_node_path = require("path");
+function getPath(dir) {
+  if ((0, import_node_path.isAbsolute)(dir))
+    return dir;
+  if ((0, import_node_path.isAbsolute)(process.argv[1]))
+    return (0, import_node_path.join)(process.argv[1], "..", dir);
+  return (0, import_node_path.join)(process.cwd(), process.argv[1], "..", dir);
+}
+function transformToUrl(path) {
+  const replacements = [
+    // Clean the url extensions
+    { regex: /\.(ts|tsx|js|jsx|mjs|cjs)$/u, replacement: "" },
+    // Fix windows slashes
+    { regex: /\\/gu, replacement: "/" },
+    // Handle wild card based routes - users/[...id]/profile.ts -> users/*/profile
+    { regex: /\[\.\.\..*\]/gu, replacement: "*" },
+    // Handle generic square bracket based routes - users/[id]/index.ts -> users/:id
+    {
+      regex: /\[(.*?)\]/gu,
+      replacement: (_, match) => `:${match}`
+    },
+    // Handle the case when multiple parameters are present in one file
+    // users / [id] - [name].ts to users /: id -:name and users / [id] - [name] / [age].ts to users /: id -: name /: age
+    { regex: /\]-\[/gu, replacement: "-:" },
+    { regex: /\]\//gu, replacement: "/" },
+    { regex: /\[/gu, replacement: "" },
+    { regex: /\]/gu, replacement: "" },
+    // remove index from end of path
+    { regex: /\/?index$/, replacement: "" }
+  ];
+  let url = path;
+  for (const { regex, replacement } of replacements) {
+    url = url.replace(regex, replacement);
+  }
+  return url;
+}
+function getParamsCount(path) {
+  return path.match(/\[(.*?)\]/gu)?.length || 0;
+}
+function sortByNestedParams(routes) {
+  return routes.sort((a, b) => getParamsCount(a) - getParamsCount(b));
+}
+function fixSlashes(prefix) {
+  if (!prefix?.endsWith("/"))
+    return prefix;
+  return prefix.slice(0, -1);
+}
+
+// src/index.ts
+var TYPES_OUTPUT_DEFAULT = "./routes-types.ts";
+var TYPES_TYPENAME_DEFAULT = "Routes";
+function autoload(options = {}) {
+  return async () => {
+    const { pattern, dir, prefix, schema, types } = options;
+    const directoryPath = getPath(dir || "./routes");
+    if (!(0, import_node_fs.existsSync)(directoryPath))
+      throw new Error(`Directory ${directoryPath} doesn't exists`);
+    if (!(0, import_node_fs.statSync)(directoryPath).isDirectory())
+      throw new Error(`${directoryPath} isn't a directory`);
+    const plugin = new import_elysia.Elysia({
+      name: "elysia-autoload",
+      prefix: fixSlashes(prefix),
+      seed: {
+        pattern,
+        dir,
+        prefix,
+        types
+      }
+    });
+    const glob = new Bun.Glob(pattern || "**/*.{ts,tsx,js,jsx,mjs,cjs}");
+    const files = await Array.fromAsync(
+      glob.scan({
+        cwd: directoryPath
+      })
+    );
+    const paths = [];
+    for await (const path of sortByNestedParams(files)) {
+      const fullPath = (0, import_node_path2.join)(directoryPath, path);
+      const file = await import(fullPath);
+      if (!file.default)
+        throw new Error(`${path} doesn't provide default export`);
+      const url = transformToUrl(path);
+      const groupOptions = schema ? schema({ path, url }) : {};
+      plugin.group(url, groupOptions, file.default);
+      if (types)
+        paths.push(fullPath.replace(directoryPath, ""));
+    }
+    if (types) {
+      const imports = paths.map(
+        (x, index) => `import type Route${index} from "${(directoryPath + x.replace(".ts", "").replace(".tsx", "")).replace(/\\/gu, "/")}";`
+      );
+      for await (const outputPath of types === true || !types.output ? [TYPES_OUTPUT_DEFAULT] : Array.isArray(types.output) ? types.output : [types.output]) {
+        await Bun.write(
+          getPath(outputPath),
+          [
+            `import type { ElysiaWithBaseUrl } from "elysia-autoload";`,
+            imports.join("\n"),
+            "",
+            types === true || !types.useExport ? "declare global {" : "",
+            `    export type ${types === true || !types.typeName ? TYPES_TYPENAME_DEFAULT : types.typeName} = ${paths.map(
+              (x, index) => `ElysiaWithBaseUrl<"${((prefix?.endsWith("/") ? prefix.slice(0, -1) : prefix) ?? "") + transformToUrl(x) || "/"}", ReturnType<typeof Route${index}>>`
+            ).join("\n              & ")}`,
+            types === true || !types.useExport ? "}" : ""
+          ].join("\n")
+        );
+      }
+    }
+    return plugin;
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  autoload
+});

package/dist/index.d.cts

@@ -0,0 +1,47 @@
+import Elysia, { RouteBase, Elysia as Elysia$1, LocalHook, InputSchema, RouteSchema, SingletonBase } from 'elysia';
+import { BaseMacro } from 'elysia/dist/types';
+
+type RemoveLastChar<T extends string> = T extends `${infer V}/` ? V : T;
+type RoutesWithPrefix<Routes extends RouteBase, Prefix extends string> = {
+    [K in keyof Routes as `${Prefix}${RemoveLastChar<K & string>}`]: Routes[K];
+};
+type ElysiaWithBaseUrl<BaseUrl extends string, ElysiaType extends Elysia<any, any, any, any, any, any, any, any>> = ElysiaType extends Elysia<infer BasePath, infer Scoped, infer Singleton, infer Definitions, infer Metadata, infer Routes, infer Ephemeral, infer Volatile> ? Elysia<BasePath, Scoped, Singleton, Definitions, Metadata, RoutesWithPrefix<Routes, BaseUrl>, Ephemeral, Volatile> : never;
+
+type TSchemaHandler = ({ path, url, }: {
+    path: string;
+    url: string;
+}) => LocalHook<InputSchema, RouteSchema, SingletonBase, Record<string, Error>, BaseMacro, "">;
+interface ITypesOptions {
+    output?: string | string[];
+    typeName?: string;
+    useExport?: boolean;
+}
+interface IAutoloadOptions {
+    pattern?: string;
+    dir?: string;
+    prefix?: string;
+    schema?: TSchemaHandler;
+    types?: ITypesOptions | true;
+}
+declare function autoload(options?: IAutoloadOptions): () => Promise<Elysia$1<string, false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>>;
+
+export { type ElysiaWithBaseUrl, type IAutoloadOptions, type ITypesOptions, autoload };

package/dist/index.d.ts

@@ -1,21 +1,29 @@
-import { Elysia } from "elysia";
+import Elysia, { RouteBase, Elysia as Elysia$1, LocalHook, InputSchema, RouteSchema, SingletonBase } from 'elysia';
+import { BaseMacro } from 'elysia/dist/types';
+
+type RemoveLastChar<T extends string> = T extends `${infer V}/` ? V : T;
+type RoutesWithPrefix<Routes extends RouteBase, Prefix extends string> = {
+    [K in keyof Routes as `${Prefix}${RemoveLastChar<K & string>}`]: Routes[K];
+};
+type ElysiaWithBaseUrl<BaseUrl extends string, ElysiaType extends Elysia<any, any, any, any, any, any, any, any>> = ElysiaType extends Elysia<infer BasePath, infer Scoped, infer Singleton, infer Definitions, infer Metadata, infer Routes, infer Ephemeral, infer Volatile> ? Elysia<BasePath, Scoped, Singleton, Definitions, Metadata, RoutesWithPrefix<Routes, BaseUrl>, Ephemeral, Volatile> : never;
+
 type TSchemaHandler = ({ path, url, }: {
     path: string;
     url: string;
-}) => Parameters<InstanceType<typeof Elysia>["group"]>[1];
-export interface ITypesOptions {
+}) => LocalHook<InputSchema, RouteSchema, SingletonBase, Record<string, Error>, BaseMacro, "">;
+interface ITypesOptions {
     output?: string | string[];
     typeName?: string;
     useExport?: boolean;
 }
-export interface IAutoloadOptions {
+interface IAutoloadOptions {
     pattern?: string;
     dir?: string;
     prefix?: string;
     schema?: TSchemaHandler;
     types?: ITypesOptions | true;
 }
-export declare function autoload(options?: IAutoloadOptions): () => Promise<Elysia<string, false, {
+declare function autoload(options?: IAutoloadOptions): () => Promise<Elysia$1<string, false, {
     decorator: {};
     store: {};
     derive: {};
@@ -35,4 +43,5 @@ export declare function autoload(options?: IAutoloadOptions): () => Promise<Elys
     resolve: {};
     schema: {};
 }>>;
-export * from "./types";
+
+export { type ElysiaWithBaseUrl, type IAutoloadOptions, type ITypesOptions, autoload };

package/dist/index.js

@@ -1,84 +1,121 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.autoload = void 0;
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
-const elysia_1 = require("elysia");
-const utils_1 = require("./utils");
-const TYPES_OUTPUT_DEFAULT = "./routes-types.ts";
-const TYPES_TYPENAME_DEFAULT = "Routes";
+// src/index.ts
+import { existsSync, statSync } from "node:fs";
+import { join as join2 } from "node:path";
+import {
+  Elysia
+} from "elysia";
+
+// src/utils.ts
+import { isAbsolute, join } from "node:path";
+function getPath(dir) {
+  if (isAbsolute(dir))
+    return dir;
+  if (isAbsolute(process.argv[1]))
+    return join(process.argv[1], "..", dir);
+  return join(process.cwd(), process.argv[1], "..", dir);
+}
+function transformToUrl(path) {
+  const replacements = [
+    // Clean the url extensions
+    { regex: /\.(ts|tsx|js|jsx|mjs|cjs)$/u, replacement: "" },
+    // Fix windows slashes
+    { regex: /\\/gu, replacement: "/" },
+    // Handle wild card based routes - users/[...id]/profile.ts -> users/*/profile
+    { regex: /\[\.\.\..*\]/gu, replacement: "*" },
+    // Handle generic square bracket based routes - users/[id]/index.ts -> users/:id
+    {
+      regex: /\[(.*?)\]/gu,
+      replacement: (_, match) => `:${match}`
+    },
+    // Handle the case when multiple parameters are present in one file
+    // users / [id] - [name].ts to users /: id -:name and users / [id] - [name] / [age].ts to users /: id -: name /: age
+    { regex: /\]-\[/gu, replacement: "-:" },
+    { regex: /\]\//gu, replacement: "/" },
+    { regex: /\[/gu, replacement: "" },
+    { regex: /\]/gu, replacement: "" },
+    // remove index from end of path
+    { regex: /\/?index$/, replacement: "" }
+  ];
+  let url = path;
+  for (const { regex, replacement } of replacements) {
+    url = url.replace(regex, replacement);
+  }
+  return url;
+}
+function getParamsCount(path) {
+  return path.match(/\[(.*?)\]/gu)?.length || 0;
+}
+function sortByNestedParams(routes) {
+  return routes.sort((a, b) => getParamsCount(a) - getParamsCount(b));
+}
+function fixSlashes(prefix) {
+  if (!prefix?.endsWith("/"))
+    return prefix;
+  return prefix.slice(0, -1);
+}
+
+// src/index.ts
+var TYPES_OUTPUT_DEFAULT = "./routes-types.ts";
+var TYPES_TYPENAME_DEFAULT = "Routes";
 function autoload(options = {}) {
-    return async () => {
-        const { pattern, dir, prefix, schema, types } = options;
-        const directoryPath = (0, utils_1.getPath)(dir || "./routes");
-        if (!(0, node_fs_1.existsSync)(directoryPath))
-            throw new Error(`Directory ${directoryPath} doesn't exists`);
-        if (!(0, node_fs_1.statSync)(directoryPath).isDirectory())
-            throw new Error(`${directoryPath} isn't a directory`);
-        const plugin = new elysia_1.Elysia({
-            name: "elysia-autoload",
-            prefix: (0, utils_1.fixSlashes)(prefix),
-            seed: {
-                pattern,
-                dir,
-                prefix,
-                types,
-            },
-        });
-        const glob = new Bun.Glob(pattern || "**/*.{ts,tsx,js,jsx,mjs,cjs}");
-        const files = await Array.fromAsync(glob.scan({
-            cwd: directoryPath,
-        }));
-        const paths = [];
-        for await (const path of (0, utils_1.sortByNestedParams)(files)) {
-            const fullPath = (0, node_path_1.join)(directoryPath, path);
-            const file = await Promise.resolve(`${fullPath}`).then(s => require(s));
-            if (!file.default)
-                throw new Error(`${path} doesn't provide default export`);
-            const url = (0, utils_1.transformToUrl)(path);
-            const groupOptions = schema ? schema({ path, url }) : {};
-            plugin.group(url, groupOptions, file.default);
-            if (types)
-                paths.push(fullPath.replace(directoryPath, ""));
-        }
-        if (types) {
-            const imports = paths.map((x, index) => `import type Route${index} from "${(directoryPath + x.replace(".ts", "").replace(".tsx", "")).replace(/\\/gu, "/")}";`);
-            for await (const outputPath of types === true || !types.output
-                ? [TYPES_OUTPUT_DEFAULT]
-                : Array.isArray(types.output)
-                    ? types.output
-                    : [types.output]) {
-                await Bun.write((0, utils_1.getPath)(outputPath), [
-                    `import type { ElysiaWithBaseUrl } from "elysia-autoload";`,
-                    imports.join("\n"),
-                    "",
-                    types === true || !types.useExport ? "declare global {" : "",
-                    `    export type ${types === true || !types.typeName
-                        ? TYPES_TYPENAME_DEFAULT
-                        : types.typeName} = ${paths
-                        .map((x, index) => `ElysiaWithBaseUrl<"${((prefix?.endsWith("/") ? prefix.slice(0, -1) : prefix) ??
-                        "") + (0, utils_1.transformToUrl)(x) || "/"}", ReturnType<typeof Route${index}>>`)
-                        .join("\n              & ")}`,
-                    types === true || !types.useExport ? "}" : "",
-                ].join("\n"));
-            }
-        }
-        return plugin;
-    };
+  return async () => {
+    const { pattern, dir, prefix, schema, types } = options;
+    const directoryPath = getPath(dir || "./routes");
+    if (!existsSync(directoryPath))
+      throw new Error(`Directory ${directoryPath} doesn't exists`);
+    if (!statSync(directoryPath).isDirectory())
+      throw new Error(`${directoryPath} isn't a directory`);
+    const plugin = new Elysia({
+      name: "elysia-autoload",
+      prefix: fixSlashes(prefix),
+      seed: {
+        pattern,
+        dir,
+        prefix,
+        types
+      }
+    });
+    const glob = new Bun.Glob(pattern || "**/*.{ts,tsx,js,jsx,mjs,cjs}");
+    const files = await Array.fromAsync(
+      glob.scan({
+        cwd: directoryPath
+      })
+    );
+    const paths = [];
+    for await (const path of sortByNestedParams(files)) {
+      const fullPath = join2(directoryPath, path);
+      const file = await import(fullPath);
+      if (!file.default)
+        throw new Error(`${path} doesn't provide default export`);
+      const url = transformToUrl(path);
+      const groupOptions = schema ? schema({ path, url }) : {};
+      plugin.group(url, groupOptions, file.default);
+      if (types)
+        paths.push(fullPath.replace(directoryPath, ""));
+    }
+    if (types) {
+      const imports = paths.map(
+        (x, index) => `import type Route${index} from "${(directoryPath + x.replace(".ts", "").replace(".tsx", "")).replace(/\\/gu, "/")}";`
+      );
+      for await (const outputPath of types === true || !types.output ? [TYPES_OUTPUT_DEFAULT] : Array.isArray(types.output) ? types.output : [types.output]) {
+        await Bun.write(
+          getPath(outputPath),
+          [
+            `import type { ElysiaWithBaseUrl } from "elysia-autoload";`,
+            imports.join("\n"),
+            "",
+            types === true || !types.useExport ? "declare global {" : "",
+            `    export type ${types === true || !types.typeName ? TYPES_TYPENAME_DEFAULT : types.typeName} = ${paths.map(
+              (x, index) => `ElysiaWithBaseUrl<"${((prefix?.endsWith("/") ? prefix.slice(0, -1) : prefix) ?? "") + transformToUrl(x) || "/"}", ReturnType<typeof Route${index}>>`
+            ).join("\n              & ")}`,
+            types === true || !types.useExport ? "}" : ""
+          ].join("\n")
+        );
+      }
+    }
+    return plugin;
+  };
 }
-exports.autoload = autoload;
-__exportStar(require("./types"), exports);
+export {
+  autoload
+};

package/package.json

@@ -1,43 +1,54 @@
-{
-    "name": "elysia-autoload",
-    "version": "0.1.9",
-    "author": "kravetsone",
-    "type": "commonjs",
-    "main": "dist/index.js",
-    "description": "Plugin for Elysia which autoload all routes in directory and code-generate types for Eden",
-    "homepage": "https://github.com/kravetsone/elysia-autoload",
-    "keywords": [
-        "bun",
-        "elysia",
-        "autoimports",
-        "autoload",
-        "nextjs",
-        "filerouter",
-        "autoroutes",
-        "eden",
-        "treaty",
-        "trpc",
-        "codegeneration"
-    ],
-    "scripts": {
-        "prepublishOnly": "bun test && rm -rf dist && tsc",
-        "lint": "bunx @biomejs/biome check src",
-        "lint:fix": "bun lint --apply",
-        "prepare": "husky"
-    },
-    "files": [
-        "dist"
-    ],
-    "devDependencies": {
-        "@biomejs/biome": "1.6.1",
-        "@elysiajs/eden": "^1.0.4",
-        "@elysiajs/swagger": "^1.0.2",
-        "@types/bun": "^1.0.8",
-        "elysia": "^1.0.5",
-        "typescript": "^5.4.2",
-        "husky": "^9.0.11"
-    },
-    "peerDependencies": {
-        "elysia": "^1.0.0"
-    }
-}
+{
+    "name": "elysia-autoload",
+    "version": "0.2.1",
+    "author": "kravetsone",
+    "type": "module",
+    "types": "./dist/index.d.ts",
+    "main": "./dist/index.js",
+    "module": "./dist/index.mjs",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "main": "./dist/index.js",
+            "module": "./dist/index.mjs"
+        }
+    },
+    "description": "Plugin for Elysia which autoload all routes in directory and code-generate types for Eden",
+    "homepage": "https://github.com/kravetsone/elysia-autoload",
+    "keywords": [
+        "bun",
+        "elysia",
+        "autoimports",
+        "autoload",
+        "nextjs",
+        "filerouter",
+        "autoroutes",
+        "eden",
+        "treaty",
+        "trpc",
+        "codegeneration"
+    ],
+    "scripts": {
+        "prepublishOnly": "bun test && bunx tsup && rm -f ./dist/index.d.mts",
+        "lint": "bunx @biomejs/biome check src",
+        "lint:fix": "bun lint --apply",
+        "prepare": "husky"
+    },
+    "files": [
+        "dist"
+    ],
+    "devDependencies": {
+        "@biomejs/biome": "1.6.3",
+        "@elysiajs/eden": "^1.0.7",
+        "@elysiajs/swagger": "^1.0.3",
+        "@microsoft/api-extractor": "^7.43.0",
+        "@types/bun": "^1.0.11",
+        "elysia": "^1.0.9",
+        "husky": "^9.0.11",
+        "tsup": "^8.0.2",
+        "typescript": "^5.4.3"
+    },
+    "peerDependencies": {
+        "elysia": "^1.0.0"
+    }
+}

package/dist/types.d.ts

@@ -1,8 +0,0 @@
-import type Elysia from "elysia";
-import type { RouteBase } from "elysia";
-type RemoveLastChar<T extends string> = T extends `${infer V}/` ? V : T;
-type RoutesWithPrefix<Routes extends RouteBase, Prefix extends string> = {
-    [K in keyof Routes as `${Prefix}${RemoveLastChar<K & string>}`]: Routes[K];
-};
-export type ElysiaWithBaseUrl<BaseUrl extends string, ElysiaType extends Elysia<any, any, any, any, any, any, any, any>> = ElysiaType extends Elysia<infer BasePath, infer Scoped, infer Singleton, infer Definitions, infer Metadata, infer Routes, infer Ephemeral, infer Volatile> ? Elysia<BasePath, Scoped, Singleton, Definitions, Metadata, RoutesWithPrefix<Routes, BaseUrl>, Ephemeral, Volatile> : never;
-export {};

package/dist/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils.d.ts

@@ -1,4 +0,0 @@
-export declare function getPath(dir: string): string;
-export declare function transformToUrl(path: string): string;
-export declare function sortByNestedParams(routes: string[]): string[];
-export declare function fixSlashes(prefix?: string): string | undefined;

package/dist/utils.js

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fixSlashes = exports.sortByNestedParams = exports.transformToUrl = exports.getPath = void 0;
-const node_path_1 = require("node:path");
-function getPath(dir) {
-    if ((0, node_path_1.isAbsolute)(dir))
-        return dir;
-    if ((0, node_path_1.isAbsolute)(process.argv[1]))
-        return (0, node_path_1.join)(process.argv[1], "..", dir);
-    return (0, node_path_1.join)(process.cwd(), process.argv[1], "..", dir);
-}
-exports.getPath = getPath;
-// Inspired by https://github.com/wobsoriano/elysia-autoroutes/blob/main/src/utils/transformPathToUrl.ts#L4C31-L4C31
-function transformToUrl(path) {
-    const replacements = [
-        // Clean the url extensions
-        { regex: /\.(ts|tsx|js|jsx|mjs|cjs)$/u, replacement: "" },
-        // Fix windows slashes
-        { regex: /\\/gu, replacement: "/" },
-        // Handle wild card based routes - users/[...id]/profile.ts -> users/*/profile
-        { regex: /\[\.\.\..*\]/gu, replacement: "*" },
-        // Handle generic square bracket based routes - users/[id]/index.ts -> users/:id
-        {
-            regex: /\[(.*?)\]/gu,
-            replacement: (_, match) => `:${match}`,
-        },
-        // Handle the case when multiple parameters are present in one file
-        // users / [id] - [name].ts to users /: id -:name and users / [id] - [name] / [age].ts to users /: id -: name /: age
-        { regex: /\]-\[/gu, replacement: "-:" },
-        { regex: /\]\//gu, replacement: "/" },
-        { regex: /\[/gu, replacement: "" },
-        { regex: /\]/gu, replacement: "" },
-        // remove index from end of path
-        { regex: /\/?index$/, replacement: "" },
-    ];
-    let url = path;
-    for (const { regex, replacement } of replacements) {
-        url = url.replace(regex, replacement);
-    }
-    return url;
-}
-exports.transformToUrl = transformToUrl;
-function getParamsCount(path) {
-    return path.match(/\[(.*?)\]/gu)?.length || 0;
-}
-// Is it necessary?..
-// Sorts by the smallest parameters
-function sortByNestedParams(routes) {
-    return routes.sort((a, b) => getParamsCount(a) - getParamsCount(b));
-}
-exports.sortByNestedParams = sortByNestedParams;
-function fixSlashes(prefix) {
-    if (!prefix?.endsWith("/"))
-        return prefix;
-    return prefix.slice(0, -1);
-}
-exports.fixSlashes = fixSlashes;