serverstruct 0.2.0 → 0.3.0

package/README.md

@@ -2,9 +2,7 @@
 
 ⚡️ Typesafe and modular servers with [Hono](https://github.com/honojs/hono).
 
-Serverstruct is a simple tool for building fast, modular and typesafe server applications.
-
-It provides structure to your Hono application without any limitations. It also supports dependency injection using [Hollywood DI](https://github.com/eriicafes/hollywood-di).
+Serverstruct is a simple tool for building fast, modular and typesafe server applications with Hono and [Hollywood DI](https://github.com/eriicafes/hollywood-di).
 
 ## Installation
 
@@ -25,9 +23,9 @@ npm i serverstruct hono hollywood-di
 ### A simple app
 
 ```ts
-import { createRoute } from "serverstruct";
+import { createModule } from "serverstruct";
 
-const app = createRoute()
+const app = createModule()
   .route((app) => {
     return app.get("/", (c) => c.text("Hello world!"));
   })
@@ -36,83 +34,103 @@ const app = createRoute()
 export default app;
 ```
 
-### An app with subroutes
+### An app with submodules
 
 ```ts
-import { createRoute } from "serverstruct";
+import { createModule } from "serverstruct";
 
 // users routes
-const users = createRoute().route((app) => {
+const users = createModule().route((app) => {
   return app.get("/", (c) => c.text("users"));
 });
 
 // posts routes
-const posts = createRoute().route((app) => {
+const posts = createModule().route((app) => {
   return app.get("/", (c) => c.text("posts"));
 });
 
-const app = createRoute()
-  .subroutes({ users, posts })
-  .route((app, container, routes) => {
+const app = createModule()
+  .submodules({ users, posts })
+  .route((app, container, modules) => {
     return app
       .get("/", (c) => c.text("Hello world!"))
-      .route("/users", routes.users)
-      .route("/posts", routes.posts);
+      .route("/users", modules.users)
+      .route("/posts", modules.posts);
   })
   .app();
 
 export default app;
 ```
 
-## Route
+## Module
 
-A route returns a new Hono app and may compose other routes with `subroutes<{ ... }>()`. If you intend to utilize dependency injection, a route can require it's dependencies with `use<{ ... }>()` and provide new dependencies with `provide({ ... })`. A route with dependencies can only be added as a subroute to another route if that route satisfies it's dependencies.
+A module is a Hono app that may require dependencies or provide dependencies of it's own. A module may compose other submodules. A module with dependencies can only be used as a submodule to another module if that module satisfies it's dependencies.
 
 ```ts
-const auth = createRoute().route((app) => {
+import { createModule } from "serverstruct";
+
+const auth = createModule().route((app) => {
+  return app; // chain route handlers here
+});
+
+const users = createModule().route((app) => {
   return app; // chain route handlers here
 });
 
-const users = createRoute().route((app) => {
+const app = createModule()
+  .submodules({ auth, users })
+  .route((app, container, modules) => {
+    return app.route("/auth", modules.auth).route("/users", modules.users);
+  })
+  .app();
+```
+
+Submodules are not automatically added to the Hono app, you will have to manually mount each route. This helps in preserving Hono's type inference through method chaining.
+
+You may also pass a custom Hono app to createModule.
+
+```ts
+import { Hono } from "hono";
+import { createModule } from "serverstruct";
+
+const auth = createModule(new Hono().basePath("/auth")).route((app) => {
   return app; // chain route handlers here
 });
 
-const posts = createRoute().route((app) => {
+const users = createModule(new Hono().basePath("/users")).route((app) => {
   return app; // chain route handlers here
 });
 
-const app = createRoute()
-  .subroutes({ auth, users, posts })
-  .route((app, container, routes) => {
-    return app
-      .route("/auth", routes.auth)
-      .route("/users", routes.users)
-      .route("/posts", routes.posts);
+const app = createModule()
+  .submodules({ auth, users })
+  .route((app, container, modules) => {
+    return app.route("", modules.auth).route("", modules.users);
   })
   .app();
 ```
 
-Subroutes are not automatically registered. You will have to manually add the route for the desired path. This also allows for Hono's type inference through method chaining.
-
 ## Dependency Injection
 
-Serverstruct is designed to work with [Hollywood DI](https://github.com/eriicafes/hollywood-di). Routes can define their dependencies using `use`, and also register new tokens using `provide` which creates a child container.
+Serverstruct is designed to work with [Hollywood DI](https://github.com/eriicafes/hollywood-di). Modules can define their dependencies using `use`, and also register new tokens using `provide`.
 
-A root container can also be passed to the route. If no container is explicitly provided the first call to provide creates a root container and futher calls to provide will inherit from it.
+A root container can also be passed to a module. If no container is explicitly provided the first call to provide creates a root container and futher calls to provide will inherit from it.
 
 ### Use
 
-Define route dependencies. The route can then only be used in a context that satisfies it's dependencies.
+Define module dependencies. The module can then only be used in a context that satisfies it's dependencies.
 
 You can only call `use` once and only before calling `provide`.
 
 ```ts
+import { Hollywood } from "hollywood-di";
+import { createModule } from "serverstruct";
+
 interface Counter {
   count: number;
   increment(): void;
 }
 
-const route = createRoute()
+const countModule = createModule()
   .use<{ counter: Counter }>()
   .route((app, container) => {
     return app.get("/", (c) => {
@@ -128,43 +146,40 @@ class LinearCounter {
   }
 }
 
-// as a subroute
-const app = createRoute()
-  .provide({ counter: LinearCounter }) // the main app provides the dependency
-  .subroutes({ countRoute: route })
-  .route((app, _, routes) => {
-    return app.route("/count", routes.countRoute);
+// as a submodule
+const app = createModule()
+  .provide({ counter: LinearCounter })
+  .submodules({ count: countModule })
+  .route((app, _, modules) => {
+    return app.route("", modules.count);
   })
   .app();
 
 // or as the main app
-const container = Hollywood.create({ counter: LinearCounter }); // the container provides the dependency
-const app = route.app(container);
+const container = Hollywood.create({ counter: LinearCounter });
+const app = countModule.app(container);
 ```
 
-Calling `Route.app()` returns the Hono instance from the route, therefore if the route has dependencies (by calling `use`), a container that satisfies those dependencies must be provided as seen in the example above.
+Calling `Module.app()` returns the Hono app, so if the module has dependencies (by calling `use`), a container that satisfies those dependencies must be provided as seen in the example above.
 
 ### Provide
 
-Provide creates a new child container. Registered tokens can then be used in the route and in futher calls to `provide`. See more about register tokens in [Hollywood DI](https://github.com/eriicafes/hollywood-di#tokens).
+Provide creates a new child container. Registered tokens can then be used in the module and in futher calls to `provide`. See more about register tokens in [Hollywood DI](https://github.com/eriicafes/hollywood-di#tokens).
 
 ```ts
-import { defineInit } from "hollywood-di";
-import { createRoute } from "serverstruct";
+import { createModule } from "serverstruct";
 
 class Foo {}
 class Bar {
-  public static init = defineInit(Bar).args("foo");
-
-  constructor(public foo: Foo) {}
+  constructor(public ctx: { foo: Foo }) {}
 }
 
-const route = createRoute()
+const module = createModule()
   .provide({
     foo: Foo,
     bar: Bar,
   })
-  .route((app, container) => {
+  .module((app, container) => {
     return app;
   });
 ```
@@ -174,21 +189,23 @@ const route = createRoute()
 Serverstruct can be added to an existing Hono app.
 
 ```ts
-// routes/posts.ts
-export const postsRoute = createRoute().route((app) => {
+// modules/posts.ts
+import { createModule } from "serverstruct";
+
+export const postsModule = createModule().route((app) => {
   return app.get("/", (c) => {
     return c.text("posts");
   });
 });
 
+// main.ts
 import { Hono } from "hono";
-import { createRoute } from "serverstruct";
-import { postsRoute } from "./routes/posts";
+import { postsModule } from "./modules/posts";
 
 const app = new Hono();
 
 app.get("/", (c) => c.text("Hello world!"));
-app.route("/posts", postsRoute.app());
+app.route("/posts", postsModule.app());
 
 export default app;
 ```

package/dist/index.d.mts

@@ -1,7 +1,9 @@
-import { AnyHollywood, HollywoodOf, RegisterTokens, InferContainer, ContainerOptions, Hollywood } from 'hollywood-di';
-import { Env, Schema, Hono } from 'hono';
-import { BlankEnv, BlankSchema } from 'hono/types';
+import { HollywoodOf, AnyHollywood, RegisterTokens, InferContainer, ContainerOptions, Hollywood } from 'hollywood-di';
+import { Hono } from 'hono';
 
+type Spread<T> = {
+    [K in keyof T]: T[K];
+} & {};
 type Merge<T, To> = T & Omit<To, keyof T>;
 type IsEmptyObject<T> = keyof T extends never ? true : false;
 type KnownKey<T> = string extends T ? never : number extends T ? never : symbol extends T ? never : T;
@@ -9,33 +11,36 @@ type KnownMappedKeys<T> = {
     [K in keyof T as KnownKey<K>]: T[K];
 } & {};
 
-type Subroute<T extends Record<string, any> = any> = {
-    app: (container: IsEmptyObject<T> extends true ? HollywoodOf<any> | undefined : HollywoodOf<T>) => Hono<any, any>;
+type SubModule<T extends Record<string, any> = any> = {
+    app: (container: IsEmptyObject<T> extends true ? HollywoodOf<any> | undefined : HollywoodOf<T>) => Hono<any, any, any>;
 };
-type Subroutes<TContainer extends Record<string, any> = any> = Record<string, Subroute<TContainer>>;
-type InferSubroutes<R extends Subroutes = {}> = {
-    [K in keyof R]: R[K] extends Route<any, infer App, any> ? App : never;
+type SubModules<TContainer extends Record<string, any> = any> = Record<string, SubModule<TContainer>>;
+type InferSubModules<R extends SubModules = {}> = {
+    [K in keyof R]: R[K] extends Module<infer App, any, any> ? App : never;
 } & {};
-declare class Route<Deps extends Record<string, any>, App extends Hono<any, any>, Routes extends Subroutes> {
-    private route;
-    private context;
-    constructor(route: (app: Hono<any, any>, container: any, routes: InferSubroutes<Routes>) => App, context: [
+declare class Module<App extends Hono<any, any, any>, Deps extends Record<string, any>, Modules extends SubModules> {
+    private _context;
+    private _route;
+    constructor(_context: [
         tokens: {
             tokens: RegisterTokens<any, any>;
             options?: ContainerOptions;
         } | undefined,
-        routes: Subroutes<any>
-    ][]);
+        routes: SubModules<any>
+    ][], _route: (container: Deps, modules: InferSubModules<Modules>) => App);
     app(container: IsEmptyObject<Deps> extends true ? HollywoodOf<any> | undefined : HollywoodOf<Deps>): App;
-    app(container?: never): IsEmptyObject<Deps> extends true ? App : never;
+    app(): IsEmptyObject<Deps> extends true ? App : never;
 }
-declare class RouteBuilder<Deps extends Record<string, any>, Container extends AnyHollywood | undefined, E extends Env, S extends Schema, Routes extends Subroutes> {
+declare class ModuleBuilder<App extends Hono<any, any, any>, Deps extends Record<string, any>, Modules extends SubModules, Container extends AnyHollywood | undefined> {
+    private app;
+    constructor(app: App);
     private context;
-    use<T extends Container extends AnyHollywood ? never : Record<string, any>>(): Container extends AnyHollywood ? never : RouteBuilder<T, HollywoodOf<T>, E, S, Routes>;
-    provide<T extends Record<string, any> = {}>(tokens: RegisterTokens<T, Container extends AnyHollywood ? InferContainer<Container> : Deps>, options?: ContainerOptions): RouteBuilder<Deps, Container extends AnyHollywood ? Hollywood<T, InferContainer<Container>> : Hollywood<T, {}>, E, S, Routes>;
-    subroutes<T extends Subroutes<Container extends AnyHollywood ? KnownMappedKeys<InferContainer<Container>> : Deps>>(routes: T): RouteBuilder<Deps, Container, E, S, Merge<T, Routes> extends infer T_1 ? { [K in keyof T_1]: Merge<T, Routes>[K]; } : never>;
-    route<App extends Hono<any, any>>(fn: (app: Hono<E, S>, container: Container extends AnyHollywood ? KnownMappedKeys<InferContainer<Container>> : Deps, routes: InferSubroutes<Routes>) => App): Route<Deps, App, Routes>;
+    use<T extends Container extends AnyHollywood ? never : Record<string, any>>(): Container extends AnyHollywood ? never : ModuleBuilder<App, T, Modules, HollywoodOf<T>>;
+    provide<T extends Record<string, any> = {}>(tokens: RegisterTokens<T, Container extends AnyHollywood ? InferContainer<Container> : Deps>, options?: ContainerOptions): ModuleBuilder<App, Deps, Modules, Container extends AnyHollywood ? Hollywood<T, InferContainer<Container>> : Hollywood<T, {}>>;
+    submodules<T extends SubModules<Container extends AnyHollywood ? KnownMappedKeys<InferContainer<Container>> : Deps>>(modules: T): ModuleBuilder<App, Deps, Spread<Merge<T, Modules>>, Container>;
+    route<T extends Hono<any, any, any>>(fn: (app: App, container: Container extends AnyHollywood ? KnownMappedKeys<InferContainer<Container>> : Deps, modules: InferSubModules<Modules>) => T): Module<T, Deps, Modules>;
 }
-declare function createRoute<E extends Env = BlankEnv>(): RouteBuilder<{}, undefined, E, BlankSchema, {}>;
+declare function createModule<App extends Hono<any, any, any> = Hono>(app: App): ModuleBuilder<App, {}, {}, undefined>;
+declare function createModule(): ModuleBuilder<Hono, {}, {}, undefined>;
 
-export { createRoute };
+export { createModule };

package/dist/index.d.ts

@@ -1,7 +1,9 @@
-import { AnyHollywood, HollywoodOf, RegisterTokens, InferContainer, ContainerOptions, Hollywood } from 'hollywood-di';
-import { Env, Schema, Hono } from 'hono';
-import { BlankEnv, BlankSchema } from 'hono/types';
+import { HollywoodOf, AnyHollywood, RegisterTokens, InferContainer, ContainerOptions, Hollywood } from 'hollywood-di';
+import { Hono } from 'hono';
 
+type Spread<T> = {
+    [K in keyof T]: T[K];
+} & {};
 type Merge<T, To> = T & Omit<To, keyof T>;
 type IsEmptyObject<T> = keyof T extends never ? true : false;
 type KnownKey<T> = string extends T ? never : number extends T ? never : symbol extends T ? never : T;
@@ -9,33 +11,36 @@ type KnownMappedKeys<T> = {
     [K in keyof T as KnownKey<K>]: T[K];
 } & {};
 
-type Subroute<T extends Record<string, any> = any> = {
-    app: (container: IsEmptyObject<T> extends true ? HollywoodOf<any> | undefined : HollywoodOf<T>) => Hono<any, any>;
+type SubModule<T extends Record<string, any> = any> = {
+    app: (container: IsEmptyObject<T> extends true ? HollywoodOf<any> | undefined : HollywoodOf<T>) => Hono<any, any, any>;
 };
-type Subroutes<TContainer extends Record<string, any> = any> = Record<string, Subroute<TContainer>>;
-type InferSubroutes<R extends Subroutes = {}> = {
-    [K in keyof R]: R[K] extends Route<any, infer App, any> ? App : never;
+type SubModules<TContainer extends Record<string, any> = any> = Record<string, SubModule<TContainer>>;
+type InferSubModules<R extends SubModules = {}> = {
+    [K in keyof R]: R[K] extends Module<infer App, any, any> ? App : never;
 } & {};
-declare class Route<Deps extends Record<string, any>, App extends Hono<any, any>, Routes extends Subroutes> {
-    private route;
-    private context;
-    constructor(route: (app: Hono<any, any>, container: any, routes: InferSubroutes<Routes>) => App, context: [
+declare class Module<App extends Hono<any, any, any>, Deps extends Record<string, any>, Modules extends SubModules> {
+    private _context;
+    private _route;
+    constructor(_context: [
         tokens: {
             tokens: RegisterTokens<any, any>;
             options?: ContainerOptions;
         } | undefined,
-        routes: Subroutes<any>
-    ][]);
+        routes: SubModules<any>
+    ][], _route: (container: Deps, modules: InferSubModules<Modules>) => App);
     app(container: IsEmptyObject<Deps> extends true ? HollywoodOf<any> | undefined : HollywoodOf<Deps>): App;
-    app(container?: never): IsEmptyObject<Deps> extends true ? App : never;
+    app(): IsEmptyObject<Deps> extends true ? App : never;
 }
-declare class RouteBuilder<Deps extends Record<string, any>, Container extends AnyHollywood | undefined, E extends Env, S extends Schema, Routes extends Subroutes> {
+declare class ModuleBuilder<App extends Hono<any, any, any>, Deps extends Record<string, any>, Modules extends SubModules, Container extends AnyHollywood | undefined> {
+    private app;
+    constructor(app: App);
     private context;
-    use<T extends Container extends AnyHollywood ? never : Record<string, any>>(): Container extends AnyHollywood ? never : RouteBuilder<T, HollywoodOf<T>, E, S, Routes>;
-    provide<T extends Record<string, any> = {}>(tokens: RegisterTokens<T, Container extends AnyHollywood ? InferContainer<Container> : Deps>, options?: ContainerOptions): RouteBuilder<Deps, Container extends AnyHollywood ? Hollywood<T, InferContainer<Container>> : Hollywood<T, {}>, E, S, Routes>;
-    subroutes<T extends Subroutes<Container extends AnyHollywood ? KnownMappedKeys<InferContainer<Container>> : Deps>>(routes: T): RouteBuilder<Deps, Container, E, S, Merge<T, Routes> extends infer T_1 ? { [K in keyof T_1]: Merge<T, Routes>[K]; } : never>;
-    route<App extends Hono<any, any>>(fn: (app: Hono<E, S>, container: Container extends AnyHollywood ? KnownMappedKeys<InferContainer<Container>> : Deps, routes: InferSubroutes<Routes>) => App): Route<Deps, App, Routes>;
+    use<T extends Container extends AnyHollywood ? never : Record<string, any>>(): Container extends AnyHollywood ? never : ModuleBuilder<App, T, Modules, HollywoodOf<T>>;
+    provide<T extends Record<string, any> = {}>(tokens: RegisterTokens<T, Container extends AnyHollywood ? InferContainer<Container> : Deps>, options?: ContainerOptions): ModuleBuilder<App, Deps, Modules, Container extends AnyHollywood ? Hollywood<T, InferContainer<Container>> : Hollywood<T, {}>>;
+    submodules<T extends SubModules<Container extends AnyHollywood ? KnownMappedKeys<InferContainer<Container>> : Deps>>(modules: T): ModuleBuilder<App, Deps, Spread<Merge<T, Modules>>, Container>;
+    route<T extends Hono<any, any, any>>(fn: (app: App, container: Container extends AnyHollywood ? KnownMappedKeys<InferContainer<Container>> : Deps, modules: InferSubModules<Modules>) => T): Module<T, Deps, Modules>;
 }
-declare function createRoute<E extends Env = BlankEnv>(): RouteBuilder<{}, undefined, E, BlankSchema, {}>;
+declare function createModule<App extends Hono<any, any, any> = Hono>(app: App): ModuleBuilder<App, {}, {}, undefined>;
+declare function createModule(): ModuleBuilder<Hono, {}, {}, undefined>;
 
-export { createRoute };
+export { createModule };

package/dist/index.js

@@ -18,25 +18,24 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  createRoute: () => createRoute
+var index_exports = {};
+__export(index_exports, {
+  createModule: () => createModule
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(index_exports);
 
-// src/route.ts
+// src/module.ts
 var import_hollywood_di = require("hollywood-di");
 var import_hono = require("hono");
-var Route = class {
-  constructor(route, context) {
-    this.route = route;
-    this.context = context;
+var Module = class {
+  constructor(_context, _route) {
+    this._context = _context;
+    this._route = _route;
   }
   app(container) {
-    var _a;
     let currentContainer = container;
-    const resolvedRoutes = {};
-    for (const [tokens, subroutes] of this.context) {
+    const resolvedModules = {};
+    for (const [tokens, submodules] of this._context) {
       let subContainer = currentContainer;
       if (tokens && subContainer) {
         subContainer = import_hollywood_di.Hollywood.createWithParent(
@@ -48,20 +47,20 @@ var Route = class {
         subContainer = import_hollywood_di.Hollywood.create(tokens.tokens, tokens.options);
       }
       currentContainer = subContainer;
-      for (const [key, subroute] of Object.entries(subroutes)) {
-        resolvedRoutes[key] = subroute.app(subContainer);
+      for (const [key, submodule] of Object.entries(submodules)) {
+        resolvedModules[key] = submodule.app(subContainer);
       }
     }
-    const instances = (_a = currentContainer == null ? void 0 : currentContainer.instances) != null ? _a : {};
-    return this.route(
-      new import_hono.Hono(),
+    const instances = currentContainer?.instances ?? {};
+    return this._route(
       instances,
-      resolvedRoutes
+      resolvedModules
     );
   }
 };
-var RouteBuilder = class {
-  constructor() {
+var ModuleBuilder = class {
+  constructor(app) {
+    this.app = app;
     this.context = [];
   }
   use() {
@@ -71,23 +70,28 @@ var RouteBuilder = class {
     this.context.push([{ tokens, options }, {}]);
     return this;
   }
-  subroutes(routes) {
-    if (!this.context.length)
-      this.context.push([void 0, routes]);
+  submodules(modules) {
+    if (!this.context.length) this.context.push([void 0, modules]);
     else {
-      const [, subroutes] = this.context[this.context.length - 1];
-      Object.assign(subroutes, routes);
+      const [, submodules] = this.context[this.context.length - 1];
+      Object.assign(submodules, modules);
     }
     return this;
   }
   route(fn) {
-    return new Route(fn, this.context);
+    return new Module(this.context, (container, modules) => {
+      return fn(
+        this.app,
+        container,
+        modules
+      );
+    });
   }
 };
-function createRoute() {
-  return new RouteBuilder();
+function createModule(app) {
+  return new ModuleBuilder(app ?? new import_hono.Hono());
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createRoute
+  createModule
 });

package/dist/index.mjs

@@ -1,18 +1,17 @@
-// src/route.ts
+// src/module.ts
 import {
   Hollywood
 } from "hollywood-di";
 import { Hono } from "hono";
-var Route = class {
-  constructor(route, context) {
-    this.route = route;
-    this.context = context;
+var Module = class {
+  constructor(_context, _route) {
+    this._context = _context;
+    this._route = _route;
   }
   app(container) {
-    var _a;
     let currentContainer = container;
-    const resolvedRoutes = {};
-    for (const [tokens, subroutes] of this.context) {
+    const resolvedModules = {};
+    for (const [tokens, submodules] of this._context) {
       let subContainer = currentContainer;
       if (tokens && subContainer) {
         subContainer = Hollywood.createWithParent(
@@ -24,20 +23,20 @@ var Route = class {
         subContainer = Hollywood.create(tokens.tokens, tokens.options);
       }
       currentContainer = subContainer;
-      for (const [key, subroute] of Object.entries(subroutes)) {
-        resolvedRoutes[key] = subroute.app(subContainer);
+      for (const [key, submodule] of Object.entries(submodules)) {
+        resolvedModules[key] = submodule.app(subContainer);
       }
     }
-    const instances = (_a = currentContainer == null ? void 0 : currentContainer.instances) != null ? _a : {};
-    return this.route(
-      new Hono(),
+    const instances = currentContainer?.instances ?? {};
+    return this._route(
       instances,
-      resolvedRoutes
+      resolvedModules
     );
   }
 };
-var RouteBuilder = class {
-  constructor() {
+var ModuleBuilder = class {
+  constructor(app) {
+    this.app = app;
     this.context = [];
   }
   use() {
@@ -47,22 +46,27 @@ var RouteBuilder = class {
     this.context.push([{ tokens, options }, {}]);
     return this;
   }
-  subroutes(routes) {
-    if (!this.context.length)
-      this.context.push([void 0, routes]);
+  submodules(modules) {
+    if (!this.context.length) this.context.push([void 0, modules]);
     else {
-      const [, subroutes] = this.context[this.context.length - 1];
-      Object.assign(subroutes, routes);
+      const [, submodules] = this.context[this.context.length - 1];
+      Object.assign(submodules, modules);
     }
     return this;
   }
   route(fn) {
-    return new Route(fn, this.context);
+    return new Module(this.context, (container, modules) => {
+      return fn(
+        this.app,
+        container,
+        modules
+      );
+    });
   }
 };
-function createRoute() {
-  return new RouteBuilder();
+function createModule(app) {
+  return new ModuleBuilder(app ?? new Hono());
 }
 export {
-  createRoute
+  createModule
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "serverstruct",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Type safe and modular servers with Hono",
   "private": false,
   "main": "./dist/index.js",
@@ -30,16 +30,16 @@
   },
   "homepage": "https://github.com/eriicafes/serverstruct#readme",
   "devDependencies": {
-    "@changesets/cli": "^2.26.2",
-    "@types/node": "^20.4.2",
-    "@vitest/coverage-v8": "^1.6.0",
+    "@changesets/cli": "^2.27.12",
+    "@types/node": "^20.17.17",
+    "@vitest/coverage-v8": "^3.0.5",
     "shx": "^0.3.4",
-    "tsup": "^7.1.0",
-    "typescript": "^5.1.6",
-    "vitest": "^1.6.0"
+    "tsup": "^8.3.6",
+    "typescript": "^5.7.3",
+    "vitest": "^3.0.5"
   },
   "peerDependencies": {
-    "hollywood-di": ">= 0.5.2",
+    "hollywood-di": ">= 0.6.1",
     "hono": ">= 4.0.0"
   },
   "scripts": {