serverstruct 0.3.0 → 1.0.0

package/README.md

@@ -1,211 +1,185 @@
 # Serverstruct
 
-⚡️ Typesafe and modular servers with [Hono](https://github.com/honojs/hono).
+⚡️ Typesafe and modular servers with [H3](https://github.com/unjs/h3).
 
-Serverstruct is a simple tool for building fast, modular and typesafe server applications with Hono and [Hollywood DI](https://github.com/eriicafes/hollywood-di).
+Serverstruct provides simple helpers for building modular h3 applications with dependency injection using [getbox](https://github.com/eriicafes/getbox).
 
 ## Installation
 
-Serverstruct requires you to install hono.
-
 ```sh
-npm i serverstruct hono
+npm i serverstruct h3 getbox
 ```
 
-To make use of dependency injection provided by serverstruct, also install hollywood-di.
-
-```sh
-npm i serverstruct hono hollywood-di
-```
+## Quick Start
 
-## Usage
+```typescript
+import { application } from "serverstruct";
 
-### A simple app
+const app = application((app) => {
+  app.get("/", () => "Hello world!");
+});
 
-```ts
-import { createModule } from "serverstruct";
+app.serve({ port: 3000 });
+```
 
-const app = createModule()
-  .route((app) => {
-    return app.get("/", (c) => c.text("Hello world!"));
-  })
-  .app();
+## Composing Apps
 
-export default app;
-```
+Create modular h3 apps and mount them together:
 
-### An app with submodules
+```typescript
+import { application } from "serverstruct";
 
-```ts
-import { createModule } from "serverstruct";
+// Create a users module
+const { app: usersApp } = application((app) => {
+  const users: User[] = [];
 
-// users routes
-const users = createModule().route((app) => {
-  return app.get("/", (c) => c.text("users"));
+  app.get("/", () => users);
+  app.post("/", async (event) => {
+    const body = await readValidatedBody(event, validateUser);
+    users.push(body);
+    return body;
+  });
 });
 
-// posts routes
-const posts = createModule().route((app) => {
-  return app.get("/", (c) => c.text("posts"));
+// Compose in main app
+const app = application((app) => {
+  app.get("/ping", () => "pong");
+  app.mount("/users", usersApp);
 });
 
-const app = createModule()
-  .submodules({ users, posts })
-  .route((app, container, modules) => {
-    return app
-      .get("/", (c) => c.text("Hello world!"))
-      .route("/users", modules.users)
-      .route("/posts", modules.posts);
-  })
-  .app();
-
-export default app;
+app.serve({ port: 3000 });
 ```
 
-## Module
+You can also create and return a new H3 instance to customize H3 options:
 
-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.
+```typescript
+import { H3 } from "h3";
 
-```ts
-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 app = application(() => {
+  const customApp = new H3({
+    onError: (error) => {
+      console.error(error);
+    },
+  });
+  customApp.get("/", () => "Hello from custom app!");
+  return customApp;
 });
-
-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.
+## Controllers with Dependency Injection
+
+Use `controller()` to create reusable modules with shared dependencies. It integrates with [getbox](https://github.com/eriicafes/getbox) for dependency injection:
 
-You may also pass a custom Hono app to createModule.
+```typescript
+import { application, controller } from "serverstruct";
 
-```ts
-import { Hono } from "hono";
-import { createModule } from "serverstruct";
+// Define a controller
+const usersController = controller((app) => {
+  const users: User[] = [];
 
-const auth = createModule(new Hono().basePath("/auth")).route((app) => {
-  return app; // chain route handlers here
+  app.get("/", () => users);
+  app.post("/", async (event) => {
+    const body = await readValidatedBody(event, validateUser);
+    users.push(body);
+    return body;
+  });
 });
 
-const users = createModule(new Hono().basePath("/users")).route((app) => {
-  return app; // chain route handlers here
+// Use it in your main app
+const app = application((app, box) => {
+  app.get("/ping", () => "pong");
+  app.mount("/users", box.new(usersController));
 });
 
-const app = createModule()
-  .submodules({ auth, users })
-  .route((app, container, modules) => {
-    return app.route("", modules.auth).route("", modules.users);
-  })
-  .app();
+app.serve({ port: 3000 });
 ```
 
-## Dependency Injection
-
-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`.
+The `box` parameter is a getbox `Box` instance that manages dependency instances.
 
-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.
+## Sharing Dependencies
 
-### Use
+Controllers can share dependencies using the `box` parameter.
 
-Define module dependencies. The module can then only be used in a context that satisfies it's dependencies.
+Use `box.get(Class)` to retrieve or create a singleton instance:
 
-You can only call `use` once and only before calling `provide`.
+```typescript
+import { application, controller } from "serverstruct";
 
-```ts
-import { Hollywood } from "hollywood-di";
-import { createModule } from "serverstruct";
+// A shared service
+class Database {
+  users: User[] = [];
 
-interface Counter {
-  count: number;
-  increment(): void;
+  getUsers() { return this.users; }
+  addUser(user: User) { this.users.push(user); }
 }
 
-const countModule = createModule()
-  .use<{ counter: Counter }>()
-  .route((app, container) => {
-    return app.get("/", (c) => {
-      container.counter.increment();
-      return c.text(`Count is: ${container.counter.count}`);
-    });
+// Controller uses box to access the database
+const usersController = controller((app, box) => {
+  const db = box.get(Database);
+
+  app.get("/", () => db.getUsers());
+  app.post("/", async (event) => {
+    const body = await readValidatedBody(event, validateUser);
+    db.addUser(body);
+    return body;
   });
+});
 
-class LinearCounter {
-  public count = 0;
-  public increment() {
-    this.count++;
-  }
-}
+// Another controller can access the same database
+const statsController = controller((app, box) => {
+  const db = box.get(Database);
 
-// 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 });
-const app = countModule.app(container);
-```
+  app.get("/count", () => ({ count: db.getUsers().length }));
+});
 
-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.
+const app = application((app, box) => {
+  app.mount("/users", box.new(usersController));
+  app.mount("/stats", box.new(statsController));
+});
 
-### Provide
+await app.serve({ port: 3000 });
+```
 
-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).
+`box.get(Class)` creates the instance on first call, then caches it.
 
-```ts
-import { createModule } from "serverstruct";
+## Middleware
 
-class Foo {}
-class Bar {
-  constructor(public ctx: { foo: Foo }) {}
-}
+Use h3's native middleware with `app.use()`:
 
-const module = createModule()
-  .provide({
-    foo: Foo,
-    bar: Bar,
-  })
-  .module((app, container) => {
-    return app;
-  });
-```
+```typescript
+const app = application((app) => {
+  // Global middleware
+  app.use(() => console.log("Request received"));
 
-## Incremental Adoption
+  app.get("/", () => "Hello world!");
+});
+```
 
-Serverstruct can be added to an existing Hono app.
+Controllers can have their own middleware:
 
-```ts
-// modules/posts.ts
-import { createModule } from "serverstruct";
+```typescript
+const usersController = controller((app) => {
+  // Runs only for routes in this controller
+  app.use(() => console.log("Users route accessed"));
 
-export const postsModule = createModule().route((app) => {
-  return app.get("/", (c) => {
-    return c.text("posts");
-  });
+  app.get("/", () => [...]);
+  app.post("/", async () => {...});
 });
+```
+
+## Custom Box Instance
+
+Pass your own Box instance to `application()` for more control:
 
-// main.ts
-import { Hono } from "hono";
-import { postsModule } from "./modules/posts";
+```typescript
+import { Box } from "getbox";
 
-const app = new Hono();
+const box = new Box();
 
-app.get("/", (c) => c.text("Hello world!"));
-app.route("/posts", postsModule.app());
+// Pre-populate with dependencies
+Box.mock(box, Database, new Database());
 
-export default app;
+const app = application((app, box) => {
+  app.mount("/users", box.new(usersController));
+}, box);
 ```

package/dist/index.cjs

@@ -0,0 +1,82 @@
+let h3 = require("h3");
+let getbox = require("getbox");
+
+//#region src/index.ts
+/**
+* Creates an h3 application with dependency injection support.
+*
+* @param fn - Function that configures the app. Receives a fresh H3 instance
+*             and Box instance. Can add routes to the provided app, or create
+*             and return a new H3 instance.
+* @param box - Optional Box instance. If not provided, creates a new one.
+* @returns Object with `app` (H3 instance) and `serve` method.
+*
+* @example
+* ```typescript
+* const app = application((app) => {
+*   app.get("/", () => "Hello world!");
+* });
+*
+* await app.serve({ port: 3000 });
+* ```
+*
+* @example With dependency injection
+* ```typescript
+* const app = application((app, box) => {
+*   app.get("/ping", () => "pong");
+*   app.mount("/users", box.new(usersController));
+* });
+*
+* await app.serve({ port: 3000 });
+* ```
+*/
+function application(fn, box = new getbox.Box()) {
+	const defaultApp = new h3.H3();
+	const app = fn(defaultApp, box) || defaultApp;
+	return {
+		app,
+		serve: (options) => (0, h3.serve)(app, options)
+	};
+}
+/**
+* Creates a Constructor that produces an h3 app when resolved.
+*
+* Use `box.new(controller)` to create fresh controller instances.
+* Controllers can use `box.get()` to access shared dependencies.
+*
+* @param fn - Function that configures the controller.
+* @returns A Constructor that can be resolved via `box.new(controller)`.
+*
+* @example
+* ```typescript
+* // Define a controller
+* const usersController = controller((app, box) => {
+*   app.get("/", () => ["Alice", "Bob"]);
+* });
+*
+* // Use it in your app
+* const app = application((app, box) => {
+*   app.mount("/users", box.new(usersController));
+* });
+* ```
+*
+* @example
+* ```typescript
+* // Controller with shared dependencies
+* class Database {
+*   getUsers() { return ["Alice", "Bob"]; }
+* }
+*
+* const usersController = controller((app, box) => {
+*   const db = box.get(Database);
+*   app.get("/", () => db.getUsers());
+* });
+* ```
+*/
+function controller(fn) {
+	return (0, getbox.factory)((box) => application(fn, box).app);
+}
+
+//#endregion
+exports.application = application;
+exports.controller = controller;

package/dist/index.d.cts

@@ -0,0 +1,75 @@
+import { H3, serve } from "h3";
+import { Box, Constructor } from "getbox";
+
+//#region src/index.d.ts
+type ServeOptions = Parameters<typeof serve>[1];
+/**
+ * Creates an h3 application with dependency injection support.
+ *
+ * @param fn - Function that configures the app. Receives a fresh H3 instance
+ *             and Box instance. Can add routes to the provided app, or create
+ *             and return a new H3 instance.
+ * @param box - Optional Box instance. If not provided, creates a new one.
+ * @returns Object with `app` (H3 instance) and `serve` method.
+ *
+ * @example
+ * ```typescript
+ * const app = application((app) => {
+ *   app.get("/", () => "Hello world!");
+ * });
+ *
+ * await app.serve({ port: 3000 });
+ * ```
+ *
+ * @example With dependency injection
+ * ```typescript
+ * const app = application((app, box) => {
+ *   app.get("/ping", () => "pong");
+ *   app.mount("/users", box.new(usersController));
+ * });
+ *
+ * await app.serve({ port: 3000 });
+ * ```
+ */
+declare function application(fn: (app: H3, box: Box) => H3 | void, box?: Box): {
+  app: H3;
+  serve: (options?: ServeOptions) => ReturnType<typeof serve>;
+};
+/**
+ * Creates a Constructor that produces an h3 app when resolved.
+ *
+ * Use `box.new(controller)` to create fresh controller instances.
+ * Controllers can use `box.get()` to access shared dependencies.
+ *
+ * @param fn - Function that configures the controller.
+ * @returns A Constructor that can be resolved via `box.new(controller)`.
+ *
+ * @example
+ * ```typescript
+ * // Define a controller
+ * const usersController = controller((app, box) => {
+ *   app.get("/", () => ["Alice", "Bob"]);
+ * });
+ *
+ * // Use it in your app
+ * const app = application((app, box) => {
+ *   app.mount("/users", box.new(usersController));
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Controller with shared dependencies
+ * class Database {
+ *   getUsers() { return ["Alice", "Bob"]; }
+ * }
+ *
+ * const usersController = controller((app, box) => {
+ *   const db = box.get(Database);
+ *   app.get("/", () => db.getUsers());
+ * });
+ * ```
+ */
+declare function controller(fn: (app: H3, box: Box) => H3 | void): Constructor<H3>;
+//#endregion
+export { ServeOptions, application, controller };

package/dist/index.d.mts

@@ -1,46 +1,75 @@
-import { HollywoodOf, AnyHollywood, RegisterTokens, InferContainer, ContainerOptions, Hollywood } from 'hollywood-di';
-import { Hono } from 'hono';
+import { H3, serve } from "h3";
+import { Box, Constructor } from "getbox";
 
-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;
-type KnownMappedKeys<T> = {
-    [K in keyof T as KnownKey<K>]: T[K];
-} & {};
-
-type SubModule<T extends Record<string, any> = any> = {
-    app: (container: IsEmptyObject<T> extends true ? HollywoodOf<any> | undefined : HollywoodOf<T>) => Hono<any, any, any>;
+//#region src/index.d.ts
+type ServeOptions = Parameters<typeof serve>[1];
+/**
+ * Creates an h3 application with dependency injection support.
+ *
+ * @param fn - Function that configures the app. Receives a fresh H3 instance
+ *             and Box instance. Can add routes to the provided app, or create
+ *             and return a new H3 instance.
+ * @param box - Optional Box instance. If not provided, creates a new one.
+ * @returns Object with `app` (H3 instance) and `serve` method.
+ *
+ * @example
+ * ```typescript
+ * const app = application((app) => {
+ *   app.get("/", () => "Hello world!");
+ * });
+ *
+ * await app.serve({ port: 3000 });
+ * ```
+ *
+ * @example With dependency injection
+ * ```typescript
+ * const app = application((app, box) => {
+ *   app.get("/ping", () => "pong");
+ *   app.mount("/users", box.new(usersController));
+ * });
+ *
+ * await app.serve({ port: 3000 });
+ * ```
+ */
+declare function application(fn: (app: H3, box: Box) => H3 | void, box?: Box): {
+  app: H3;
+  serve: (options?: ServeOptions) => ReturnType<typeof serve>;
 };
-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 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: SubModules<any>
-    ][], _route: (container: Deps, modules: InferSubModules<Modules>) => App);
-    app(container: IsEmptyObject<Deps> extends true ? HollywoodOf<any> | undefined : HollywoodOf<Deps>): App;
-    app(): IsEmptyObject<Deps> extends true ? App : never;
-}
-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 : 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 createModule<App extends Hono<any, any, any> = Hono>(app: App): ModuleBuilder<App, {}, {}, undefined>;
-declare function createModule(): ModuleBuilder<Hono, {}, {}, undefined>;
-
-export { createModule };
+/**
+ * Creates a Constructor that produces an h3 app when resolved.
+ *
+ * Use `box.new(controller)` to create fresh controller instances.
+ * Controllers can use `box.get()` to access shared dependencies.
+ *
+ * @param fn - Function that configures the controller.
+ * @returns A Constructor that can be resolved via `box.new(controller)`.
+ *
+ * @example
+ * ```typescript
+ * // Define a controller
+ * const usersController = controller((app, box) => {
+ *   app.get("/", () => ["Alice", "Bob"]);
+ * });
+ *
+ * // Use it in your app
+ * const app = application((app, box) => {
+ *   app.mount("/users", box.new(usersController));
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Controller with shared dependencies
+ * class Database {
+ *   getUsers() { return ["Alice", "Bob"]; }
+ * }
+ *
+ * const usersController = controller((app, box) => {
+ *   const db = box.get(Database);
+ *   app.get("/", () => db.getUsers());
+ * });
+ * ```
+ */
+declare function controller(fn: (app: H3, box: Box) => H3 | void): Constructor<H3>;
+//#endregion
+export { ServeOptions, application, controller };

package/dist/index.mjs

@@ -1,72 +1,81 @@
-// src/module.ts
-import {
-  Hollywood
-} from "hollywood-di";
-import { Hono } from "hono";
-var Module = class {
-  constructor(_context, _route) {
-    this._context = _context;
-    this._route = _route;
-  }
-  app(container) {
-    let currentContainer = container;
-    const resolvedModules = {};
-    for (const [tokens, submodules] of this._context) {
-      let subContainer = currentContainer;
-      if (tokens && subContainer) {
-        subContainer = Hollywood.createWithParent(
-          subContainer,
-          tokens.tokens,
-          tokens.options
-        );
-      } else if (tokens) {
-        subContainer = Hollywood.create(tokens.tokens, tokens.options);
-      }
-      currentContainer = subContainer;
-      for (const [key, submodule] of Object.entries(submodules)) {
-        resolvedModules[key] = submodule.app(subContainer);
-      }
-    }
-    const instances = currentContainer?.instances ?? {};
-    return this._route(
-      instances,
-      resolvedModules
-    );
-  }
-};
-var ModuleBuilder = class {
-  constructor(app) {
-    this.app = app;
-    this.context = [];
-  }
-  use() {
-    return this;
-  }
-  provide(tokens, options) {
-    this.context.push([{ tokens, options }, {}]);
-    return this;
-  }
-  submodules(modules) {
-    if (!this.context.length) this.context.push([void 0, modules]);
-    else {
-      const [, submodules] = this.context[this.context.length - 1];
-      Object.assign(submodules, modules);
-    }
-    return this;
-  }
-  route(fn) {
-    return new Module(this.context, (container, modules) => {
-      return fn(
-        this.app,
-        container,
-        modules
-      );
-    });
-  }
-};
-function createModule(app) {
-  return new ModuleBuilder(app ?? new Hono());
+import { H3, serve } from "h3";
+import { Box, factory } from "getbox";
+
+//#region src/index.ts
+/**
+* Creates an h3 application with dependency injection support.
+*
+* @param fn - Function that configures the app. Receives a fresh H3 instance
+*             and Box instance. Can add routes to the provided app, or create
+*             and return a new H3 instance.
+* @param box - Optional Box instance. If not provided, creates a new one.
+* @returns Object with `app` (H3 instance) and `serve` method.
+*
+* @example
+* ```typescript
+* const app = application((app) => {
+*   app.get("/", () => "Hello world!");
+* });
+*
+* await app.serve({ port: 3000 });
+* ```
+*
+* @example With dependency injection
+* ```typescript
+* const app = application((app, box) => {
+*   app.get("/ping", () => "pong");
+*   app.mount("/users", box.new(usersController));
+* });
+*
+* await app.serve({ port: 3000 });
+* ```
+*/
+function application(fn, box = new Box()) {
+	const defaultApp = new H3();
+	const app = fn(defaultApp, box) || defaultApp;
+	return {
+		app,
+		serve: (options) => serve(app, options)
+	};
 }
-export {
-  createModule
-};
+/**
+* Creates a Constructor that produces an h3 app when resolved.
+*
+* Use `box.new(controller)` to create fresh controller instances.
+* Controllers can use `box.get()` to access shared dependencies.
+*
+* @param fn - Function that configures the controller.
+* @returns A Constructor that can be resolved via `box.new(controller)`.
+*
+* @example
+* ```typescript
+* // Define a controller
+* const usersController = controller((app, box) => {
+*   app.get("/", () => ["Alice", "Bob"]);
+* });
+*
+* // Use it in your app
+* const app = application((app, box) => {
+*   app.mount("/users", box.new(usersController));
+* });
+* ```
+*
+* @example
+* ```typescript
+* // Controller with shared dependencies
+* class Database {
+*   getUsers() { return ["Alice", "Bob"]; }
+* }
+*
+* const usersController = controller((app, box) => {
+*   const db = box.get(Database);
+*   app.get("/", () => db.getUsers());
+* });
+* ```
+*/
+function controller(fn) {
+	return factory((box) => application(fn, box).app);
+}
+
+//#endregion
+export { application, controller };

package/package.json

@@ -1,22 +1,34 @@
 {
   "name": "serverstruct",
-  "version": "0.3.0",
-  "description": "Type safe and modular servers with Hono",
+  "version": "1.0.0",
+  "description": "Type safe and modular servers with H3",
   "private": false,
-  "main": "./dist/index.js",
+  "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
-  "types": "./dist/index.d.ts",
+  "types": "./dist/index.d.cts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs",
-      "default": "./dist/index.js"
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
     }
   },
+  "scripts": {
+    "build": "tsc && tsdown src/index.ts --format esm,cjs",
+    "release": "pnpm run build && changeset publish",
+    "watch": "vitest",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage"
+  },
   "keywords": [
-    "hono",
+    "h3",
     "server",
-    "hollywood-di",
+    "DI",
     "typescript"
   ],
   "author": "Eric Afes <eriicafes@gmail.com>",
@@ -30,24 +42,15 @@
   },
   "homepage": "https://github.com/eriicafes/serverstruct#readme",
   "devDependencies": {
-    "@changesets/cli": "^2.27.12",
-    "@types/node": "^20.17.17",
-    "@vitest/coverage-v8": "^3.0.5",
-    "shx": "^0.3.4",
-    "tsup": "^8.3.6",
-    "typescript": "^5.7.3",
-    "vitest": "^3.0.5"
+    "@changesets/cli": "^2.29.8",
+    "@types/node": "^25.0.3",
+    "@vitest/coverage-v8": "^4.0.16",
+    "tsdown": "^0.18.3",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.16"
   },
   "peerDependencies": {
-    "hollywood-di": ">= 0.6.1",
-    "hono": ">= 4.0.0"
-  },
-  "scripts": {
-    "prebuild": "shx rm -rf dist",
-    "build": "tsc --noEmit && tsup src/index.ts --format esm,cjs --dts",
-    "release": "pnpm run build && changeset publish",
-    "watch": "vitest",
-    "test": "vitest run",
-    "test:coverage": "vitest run --coverage"
+    "getbox": ">= 1.0.0 <2.0.0",
+    "h3": ">=2.0.1-rc.6 <3.0.0"
   }
 }

package/dist/index.d.ts

@@ -1,46 +0,0 @@
-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;
-type KnownMappedKeys<T> = {
-    [K in keyof T as KnownKey<K>]: T[K];
-} & {};
-
-type SubModule<T extends Record<string, any> = any> = {
-    app: (container: IsEmptyObject<T> extends true ? HollywoodOf<any> | undefined : HollywoodOf<T>) => Hono<any, any, any>;
-};
-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 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: SubModules<any>
-    ][], _route: (container: Deps, modules: InferSubModules<Modules>) => App);
-    app(container: IsEmptyObject<Deps> extends true ? HollywoodOf<any> | undefined : HollywoodOf<Deps>): App;
-    app(): IsEmptyObject<Deps> extends true ? App : never;
-}
-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 : 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 createModule<App extends Hono<any, any, any> = Hono>(app: App): ModuleBuilder<App, {}, {}, undefined>;
-declare function createModule(): ModuleBuilder<Hono, {}, {}, undefined>;
-
-export { createModule };

package/dist/index.js

@@ -1,97 +0,0 @@
-"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 index_exports = {};
-__export(index_exports, {
-  createModule: () => createModule
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/module.ts
-var import_hollywood_di = require("hollywood-di");
-var import_hono = require("hono");
-var Module = class {
-  constructor(_context, _route) {
-    this._context = _context;
-    this._route = _route;
-  }
-  app(container) {
-    let currentContainer = container;
-    const resolvedModules = {};
-    for (const [tokens, submodules] of this._context) {
-      let subContainer = currentContainer;
-      if (tokens && subContainer) {
-        subContainer = import_hollywood_di.Hollywood.createWithParent(
-          subContainer,
-          tokens.tokens,
-          tokens.options
-        );
-      } else if (tokens) {
-        subContainer = import_hollywood_di.Hollywood.create(tokens.tokens, tokens.options);
-      }
-      currentContainer = subContainer;
-      for (const [key, submodule] of Object.entries(submodules)) {
-        resolvedModules[key] = submodule.app(subContainer);
-      }
-    }
-    const instances = currentContainer?.instances ?? {};
-    return this._route(
-      instances,
-      resolvedModules
-    );
-  }
-};
-var ModuleBuilder = class {
-  constructor(app) {
-    this.app = app;
-    this.context = [];
-  }
-  use() {
-    return this;
-  }
-  provide(tokens, options) {
-    this.context.push([{ tokens, options }, {}]);
-    return this;
-  }
-  submodules(modules) {
-    if (!this.context.length) this.context.push([void 0, modules]);
-    else {
-      const [, submodules] = this.context[this.context.length - 1];
-      Object.assign(submodules, modules);
-    }
-    return this;
-  }
-  route(fn) {
-    return new Module(this.context, (container, modules) => {
-      return fn(
-        this.app,
-        container,
-        modules
-      );
-    });
-  }
-};
-function createModule(app) {
-  return new ModuleBuilder(app ?? new import_hono.Hono());
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createModule
-});