elysia-autoload 0.2.4 → 1.0.1

package/README.md

@@ -1,6 +1,6 @@
 # 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)
+Plugin for [Elysia](https://elysiajs.com/) which autoload all routes in directory and code-generate types for [Eden](https://elysiajs.com/eden/overview.html) with [`Bun.build`](https://bun.sh/docs/bundler) support!
 
 **Currently, Eden types generation is broken!!**
 
@@ -28,11 +28,16 @@ bun install elysia-autoload
 import { Elysia } from "elysia";
 import { autoload } from "elysia-autoload";
 
-const app = new Elysia().use(autoload()).listen(3000);
+const app = new Elysia().use(await autoload()).listen(3000);
 
 export type ElysiaApp = typeof app;
 ```
 
+> [!IMPORTANT]
+> We strictly recommend use `await` when registering plugin
+>
+> Read more about [Lazy-load plugins](https://elysiajs.com/patterns/lazy-loading-module.html)
+
 ## Create route
 
 ```ts
@@ -99,7 +104,7 @@ import { autoload } from "elysia-autoload";
 
 const app = new Elysia()
     .use(
-        autoload({
+        await autoload({
             types: {
                 output: "./routes.ts",
                 typeName: "Routes",
@@ -129,8 +134,44 @@ const { data } = await app.test["some-path-param"].get({
 console.log(data);
 ```
 
+`routes.ts` will be:
+
+```ts
+// @filename: routes.ts
+
+import type { ElysiaWithBaseUrl } from "elysia-autoload";
+import type Route0 from "./routes/index";
+import type Route1 from "./routes/test/[some]/index";
+
+declare global {
+    export type Routes = ElysiaWithBaseUrl<"/api", ReturnType<typeof Route0>> &
+        ElysiaWithBaseUrl<"/api/test/:some", ReturnType<typeof Route1>>;
+}
+```
+
 Example of app with types code-generation you can see in [example](https://github.com/kravetsone/elysia-autoload/tree/main/example)
 
+**Currently, Eden types generation is broken!!**
+
+### Bun build usage
+
+You can use this plugin with `Bun.build`, thanks to [esbuild-plugin-autoload](https://github.com/kravetsone/esbuild-plugin-autoload)!
+
+```ts
+// @filename: build.ts
+import { autoload } from "esbuild-plugin-autoload"; // default import also supported
+
+await Bun.build({
+    entrypoints: ["src/index.ts"],
+    outdir: "out",
+    plugins: [autoload()],
+}).then(console.log);
+```
+
+Then, build it with `bun build.ts` and run with `bun out/index.ts`.
+
+[Read more](https://github.com/kravetsone/esbuild-plugin-autoload)
+
 ### Usage of schema handler
 
 ```ts
@@ -140,7 +181,7 @@ import { autoload } from "elysia-autoload";
 
 const app = new Elysia()
     .use(
-        autoload({
+        await autoload({
             schema: ({ path, url }) => {
                 const tag = url.split("/").at(1)!;
 

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -23,18 +33,20 @@ __export(src_exports, {
   autoload: () => autoload
 });
 module.exports = __toCommonJS(src_exports);
-var import_node_fs = require("fs");
-var import_node_path2 = require("path");
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
 var import_elysia = require("elysia");
 
 // src/utils.ts
-var import_node_path = require("path");
+var import_node_path = __toESM(require("path"), 1);
 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);
+  if (import_node_path.default.isAbsolute(dir))
+    return dir;
+  if (import_node_path.default.isAbsolute(process.argv[1]))
+    return import_node_path.default.join(process.argv[1], "..", dir);
+  return import_node_path.default.join(process.cwd(), process.argv[1], "..", dir);
 }
-function transformToUrl(path) {
+function transformToUrl(path3) {
   const replacements = [
     // Clean the url extensions
     { regex: /\.(ts|tsx|js|jsx|mjs|cjs)$/u, replacement: "" },
@@ -56,32 +68,51 @@ function transformToUrl(path) {
     // remove index from end of path
     { regex: /\/?index$/, replacement: "" }
   ];
-  let url = path;
+  let url = path3;
   for (const { regex, replacement } of replacements) {
     url = url.replace(regex, replacement);
   }
   return url;
 }
-function getParamsCount(path) {
-  return path.match(/\[(.*?)\]/gu)?.length || 0;
+function getParamsCount(path3) {
+  return path3.match(/\[(.*?)\]/gu)?.length || 0;
 }
 function sortByNestedParams(routes) {
   return routes.sort((a, b) => getParamsCount(a) - getParamsCount(b));
 }
 function fixSlashes(prefix) {
-  if (!prefix?.endsWith("/")) return prefix;
+  if (!prefix?.endsWith("/"))
+    return prefix;
   return prefix.slice(0, -1);
 }
+function addRelativeIfNotDot(path3) {
+  if (path3.at(0) !== ".")
+    return `./${path3}`;
+  return path3;
+}
 
 // src/index.ts
+var DIR_ROUTES_DEFAULT = "./routes";
 var TYPES_OUTPUT_DEFAULT = "./routes-types.ts";
 var TYPES_TYPENAME_DEFAULT = "Routes";
+var TYPES_OBJECT_DEFAULT = {
+  output: [TYPES_OUTPUT_DEFAULT],
+  typeName: TYPES_TYPENAME_DEFAULT
+};
 async function autoload(options = {}) {
-  const { pattern, dir, prefix, schema, types } = options;
-  const directoryPath = getPath(dir || "./routes");
-  if (!(0, import_node_fs.existsSync)(directoryPath))
+  const fileSources = {};
+  const { pattern, prefix, schema } = options;
+  const dir = options.dir ?? DIR_ROUTES_DEFAULT;
+  const types = options.types && options.types !== true ? {
+    ...TYPES_OBJECT_DEFAULT,
+    ...options.types,
+    // This code allows you to omit the output data or specify it as an string[] or string.
+    output: !options.types.output ? [TYPES_OUTPUT_DEFAULT] : Array.isArray(options.types.output) ? options.types.output : [options.types.output]
+  } : TYPES_OBJECT_DEFAULT;
+  const directoryPath = getPath(dir);
+  if (!import_node_fs.default.existsSync(directoryPath))
     throw new Error(`Directory ${directoryPath} doesn't exists`);
-  if (!(0, import_node_fs.statSync)(directoryPath).isDirectory())
+  if (!import_node_fs.default.statSync(directoryPath).isDirectory())
     throw new Error(`${directoryPath} isn't a directory`);
   const plugin = new import_elysia.Elysia({
     name: "elysia-autoload",
@@ -100,32 +131,39 @@ async function autoload(options = {}) {
     })
   );
   const paths = [];
-  for await (const path of sortByNestedParams(files)) {
-    const fullPath = (0, import_node_path2.join)(directoryPath, path);
+  for await (const filePath of sortByNestedParams(files)) {
+    const fullPath = import_node_path2.default.join(directoryPath, filePath);
     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 }) : {};
+      throw new Error(`${filePath} doesn't provide default export`);
+    const url = transformToUrl(filePath);
+    const groupOptions = schema ? schema({ path: filePath, url }) : {};
     plugin.group(url, groupOptions, file.default);
-    if (types) paths.push(fullPath.replace(directoryPath, ""));
+    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]) {
+    for await (const outputPath of types.output) {
+      const outputAbsolutePath = getPath(outputPath);
+      const imports = paths.map(
+        (x, index) => `import type Route${index} from "${addRelativeIfNotDot(
+          import_node_path2.default.relative(
+            import_node_path2.default.dirname(outputAbsolutePath),
+            directoryPath + x.replace(".ts", "").replace(".tsx", "")
+          ).replace(/\\/gu, "/")
+        )}";`
+      );
       await Bun.write(
-        getPath(outputPath),
+        outputAbsolutePath,
         [
           `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(
+          !types.useExport ? "declare global {" : "",
+          `    export type ${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 ? "}" : ""
+          !types.useExport ? "}" : ""
         ].join("\n")
       );
     }

package/dist/index.js

@@ -1,18 +1,20 @@
 // src/index.ts
-import { existsSync, statSync } from "node:fs";
-import { join as join2 } from "node:path";
+import fs from "node:fs";
+import path2 from "node:path";
 import {
   Elysia
 } from "elysia";
 
 // src/utils.ts
-import { isAbsolute, join } from "node:path";
+import path 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);
+  if (path.isAbsolute(dir))
+    return dir;
+  if (path.isAbsolute(process.argv[1]))
+    return path.join(process.argv[1], "..", dir);
+  return path.join(process.cwd(), process.argv[1], "..", dir);
 }
-function transformToUrl(path) {
+function transformToUrl(path3) {
   const replacements = [
     // Clean the url extensions
     { regex: /\.(ts|tsx|js|jsx|mjs|cjs)$/u, replacement: "" },
@@ -34,32 +36,51 @@ function transformToUrl(path) {
     // remove index from end of path
     { regex: /\/?index$/, replacement: "" }
   ];
-  let url = path;
+  let url = path3;
   for (const { regex, replacement } of replacements) {
     url = url.replace(regex, replacement);
   }
   return url;
 }
-function getParamsCount(path) {
-  return path.match(/\[(.*?)\]/gu)?.length || 0;
+function getParamsCount(path3) {
+  return path3.match(/\[(.*?)\]/gu)?.length || 0;
 }
 function sortByNestedParams(routes) {
   return routes.sort((a, b) => getParamsCount(a) - getParamsCount(b));
 }
 function fixSlashes(prefix) {
-  if (!prefix?.endsWith("/")) return prefix;
+  if (!prefix?.endsWith("/"))
+    return prefix;
   return prefix.slice(0, -1);
 }
+function addRelativeIfNotDot(path3) {
+  if (path3.at(0) !== ".")
+    return `./${path3}`;
+  return path3;
+}
 
 // src/index.ts
+var DIR_ROUTES_DEFAULT = "./routes";
 var TYPES_OUTPUT_DEFAULT = "./routes-types.ts";
 var TYPES_TYPENAME_DEFAULT = "Routes";
+var TYPES_OBJECT_DEFAULT = {
+  output: [TYPES_OUTPUT_DEFAULT],
+  typeName: TYPES_TYPENAME_DEFAULT
+};
 async function autoload(options = {}) {
-  const { pattern, dir, prefix, schema, types } = options;
-  const directoryPath = getPath(dir || "./routes");
-  if (!existsSync(directoryPath))
+  const fileSources = {};
+  const { pattern, prefix, schema } = options;
+  const dir = options.dir ?? DIR_ROUTES_DEFAULT;
+  const types = options.types && options.types !== true ? {
+    ...TYPES_OBJECT_DEFAULT,
+    ...options.types,
+    // This code allows you to omit the output data or specify it as an string[] or string.
+    output: !options.types.output ? [TYPES_OUTPUT_DEFAULT] : Array.isArray(options.types.output) ? options.types.output : [options.types.output]
+  } : TYPES_OBJECT_DEFAULT;
+  const directoryPath = getPath(dir);
+  if (!fs.existsSync(directoryPath))
     throw new Error(`Directory ${directoryPath} doesn't exists`);
-  if (!statSync(directoryPath).isDirectory())
+  if (!fs.statSync(directoryPath).isDirectory())
     throw new Error(`${directoryPath} isn't a directory`);
   const plugin = new Elysia({
     name: "elysia-autoload",
@@ -78,32 +99,39 @@ async function autoload(options = {}) {
     })
   );
   const paths = [];
-  for await (const path of sortByNestedParams(files)) {
-    const fullPath = join2(directoryPath, path);
+  for await (const filePath of sortByNestedParams(files)) {
+    const fullPath = path2.join(directoryPath, filePath);
     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 }) : {};
+      throw new Error(`${filePath} doesn't provide default export`);
+    const url = transformToUrl(filePath);
+    const groupOptions = schema ? schema({ path: filePath, url }) : {};
     plugin.group(url, groupOptions, file.default);
-    if (types) paths.push(fullPath.replace(directoryPath, ""));
+    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]) {
+    for await (const outputPath of types.output) {
+      const outputAbsolutePath = getPath(outputPath);
+      const imports = paths.map(
+        (x, index) => `import type Route${index} from "${addRelativeIfNotDot(
+          path2.relative(
+            path2.dirname(outputAbsolutePath),
+            directoryPath + x.replace(".ts", "").replace(".tsx", "")
+          ).replace(/\\/gu, "/")
+        )}";`
+      );
       await Bun.write(
-        getPath(outputPath),
+        outputAbsolutePath,
         [
           `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(
+          !types.useExport ? "declare global {" : "",
+          `    export type ${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 ? "}" : ""
+          !types.useExport ? "}" : ""
         ].join("\n")
       );
     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "elysia-autoload",
-    "version": "0.2.4",
+    "version": "1.0.1",
     "author": "kravetsone",
     "type": "module",
     "types": "./dist/index.d.ts",