@wooksjs/express-adapter 0.4.9 → 0.7.0

package/README.md

@@ -1,6 +1,4 @@
-# Express Adapter (Wooks Composables)
-
-**!!! This is work-in-progress library, breaking changes are expected !!!**
+# @wooksjs/express-adapter
 
 <p align="center">
 <img src="./docs/wooksjs-express.png" height="156px"><br>
@@ -9,76 +7,167 @@
 </a>
 </p>
 
-Want to use [@wooksjs/event-http](https://www.npmjs.com/package/@wooksjs/event-http) but your project is coupled with express? ✅ This is not a problem with this Express Adapter for [wooks](https://www.npmjs.com/package/wooks)
+Use [Wooks](https://wooks.moost.org) composables with [Express](https://expressjs.com). This adapter lets you register Wooks-style route handlers on top of an existing Express app — unmatched requests automatically fall through to Express middleware.
 
 ## Install
 
-`npm install @wooksjs/express-adapter @wooksjs/event-http`
-
-## Usage
+```bash
+npm install @wooksjs/express-adapter @wooksjs/event-http wooks express
+```
 
-There are two options to use express with wooks
+## Quick Start
 
-### 1. Adapter for express API:
-This one will modify express `get`, `post`, ..., methods. Take this one if you want to keep using express app API.
 ```ts
 import express from 'express'
-import { applyExpressAdapter } from '@wooksjs/express-adapter'
-import { useBody } from '@wooksjs/http-body'
-import { HttpError } from '@wooksjs/event-http'
-import { useRouteParams } from '@wooksjs/event-core'
+import { WooksExpress } from '@wooksjs/express-adapter'
+import { useRouteParams, useRequest, HttpError } from '@wooksjs/event-http'
 
 const app = express()
+const wooks = new WooksExpress(app)
 
-applyExpressAdapter(app)
-
-app.get('/test/:param', () => {
+// Return values become the response body
+wooks.get('/hello/:name', () => {
     const { get } = useRouteParams()
-    return { message: 'it works', param: get('param') }
+    return { hello: get('name') }
 })
 
-app.post('/post', () => {
-    const { parseBody } = useBody()
-    return parseBody()
+// Async handlers work out of the box
+wooks.post('/upload', async () => {
+    const { rawBody } = useRequest()
+    const body = await rawBody()
+    return { received: body.length }
 })
 
-app.get('/error', () => {
-    throw new HttpError(400, 'test error')
+// Throw HttpError for error responses
+wooks.get('/protected', () => {
+    throw new HttpError(403, 'Forbidden')
 })
 
-app.listen(3000, () => console.log('listening 3000'))
+app.listen(3000, () => console.log('listening on 3000'))
 ```
 
-### 2. Adapter for WooksHttp API:
-This one does not modify anything. It just applies express middleware and reroutes requests through wooks. Use this one if you want to use wooks app API (compatible with [@moostjs/event-http](https://www.npmjs.com/package/@moostjs/event-http))
+## How It Works
+
+`WooksExpress` extends `WooksHttp` and registers itself as Express middleware. When a request comes in:
+
+1. Wooks checks if a matching route is registered
+2. If matched — the Wooks handler runs with full composable support
+3. If not matched — the request falls through to the next Express middleware
+
+This means you can **mix Wooks routes with regular Express routes and middleware**:
 
 ```ts
 import express from 'express'
 import { WooksExpress } from '@wooksjs/express-adapter'
-import { useBody } from '@wooksjs/http-body'
-import { HttpError } from '@wooksjs/event-http'
-import { useRouteParams } from '@wooksjs/event-core'
+import cors from 'cors'
 
-const expressApp = express()
+const app = express()
 
-const wooksApp = new WooksExpress(expressApp, { raise404: true })
+// Express middleware works as usual
+app.use(cors())
+app.use(express.json())
 
-wooksApp.get('/test/:param', () => {
-    const { get } = useRouteParams()
-    return { message: 'it works', param: get('param') }
+// Wooks handles these routes
+const wooks = new WooksExpress(app)
+wooks.get('/api/users', () => {
+    return [{ id: 1, name: 'Alice' }]
 })
 
-wooksApp.post('/post', () => {
-    const { parseBody } = useBody()
-    return parseBody()
+// Express handles this route
+app.get('/legacy', (req, res) => {
+    res.send('handled by express')
 })
 
-wooksApp.get('/error', () => {
-    throw new HttpError(400, 'test error')
+app.listen(3000)
+```
+
+## API
+
+### `new WooksExpress(expressApp, options?)`
+
+Creates a new adapter instance and registers Wooks middleware on the Express app.
+
+| Option           | Type                       | Default | Description                                                                      |
+| ---------------- | -------------------------- | ------- | -------------------------------------------------------------------------------- |
+| `raise404`       | `boolean`                  | `false` | Return 404 from Wooks for unmatched routes instead of falling through to Express |
+| `onNotFound`     | `() => unknown`            | —       | Custom handler for unmatched routes                                              |
+| `logger`         | `TConsoleBase`             | —       | Custom logger instance                                                           |
+| `router`         | `object`                   | —       | Router options (`ignoreTrailingSlash`, `ignoreCase`, `cacheLimit`)               |
+| `requestLimits`  | `object`                   | —       | Default request body size limits                                                 |
+| `defaultHeaders` | `Record<string, string>`   | —       | Headers added to every response                                                  |
+| `responseClass`  | `typeof WooksHttpResponse` | —       | Custom response class                                                            |
+
+### Route Methods
+
+```ts
+wooks.get(path, handler)
+wooks.post(path, handler)
+wooks.put(path, handler)
+wooks.patch(path, handler)
+wooks.delete(path, handler)
+wooks.head(path, handler)
+wooks.options(path, handler)
+wooks.all(path, handler)
+```
+
+Handlers take **no arguments** — use composables to access request data:
+
+```ts
+wooks.get('/users/:id', () => {
+    const { get } = useRouteParams()
+    const { method, url, rawBody, getIp } = useRequest()
+    const headers = useHeaders()
+    const response = useResponse()
+
+    response.setHeader('x-custom', 'value')
+    return { id: get('id') }
 })
+```
+
+### `wooks.listen(port)`
+
+Starts the Express server and returns a promise that resolves when listening.
+
+```ts
+await wooks.listen(3000)
+```
+
+### `wooks.close()`
+
+Stops the server.
+
+```ts
+await wooks.close()
+```
+
+## Available Composables
+
+These come from `@wooksjs/event-http` and work inside any Wooks handler:
+
+| Composable           | Purpose                                     |
+| -------------------- | ------------------------------------------- |
+| `useRequest()`       | Request method, URL, headers, body, IP      |
+| `useRouteParams()`   | Route parameters (`:id`, etc.)              |
+| `useHeaders()`       | Request headers                             |
+| `useResponse()`      | Set status, headers, cookies, cache control |
+| `useCookies()`       | Read request cookies                        |
+| `useUrlParams()`     | URL query parameters                        |
+| `useAuthorization()` | Parse Authorization header                  |
+| `useAccept()`        | Check Accept header                         |
+| `useLogger()`        | Event-scoped logger                         |
+
+See the [Wooks documentation](https://wooks.moost.org) for full composable reference.
+
+## Development
 
-wooksApp.listen(3000, () => console.log('listening 3000'))
+```bash
+npm install       # install dependencies
+npm test          # run tests (vitest)
+npm run build     # build for distribution
+npm run lint      # lint with oxlint
+npm run fmt       # format with oxfmt
 ```
 
+## License
 
-⚠️ Check out official [wooks documentation](https://wooksjs.org/guide/http/express.html).
+[MIT](./LICENSE)

package/dist/index.cjs

@@ -1,101 +1,69 @@
 'use strict';
 
 const eventHttp = require('@wooksjs/event-http');
-
-const methods = [
-  "get",
-  "post",
-  "delete",
-  "put",
-  "patch",
-  "options",
-  "head",
-  "all"
-];
-function applyExpressAdapter(app, eventOptions) {
-  const responder = eventHttp.createWooksResponder();
-  function useWooksDecorator(fn) {
-    return async () => {
-      const { restoreCtx, clearCtx } = eventHttp.useHttpContext();
-      try {
-        const result = await fn();
-        restoreCtx();
-        await responder.respond(result);
-      } catch (e) {
-        restoreCtx();
-        await responder.respond(e);
-      }
-      clearCtx();
-    };
-  }
-  app.use(wooksContext(eventOptions));
-  for (const m of methods) {
-    const defFn = app[m].bind(app);
-    const newFn = ((...args) => {
-      return defFn(...args.map((a) => typeof a === "function" ? useWooksDecorator(a) : a));
-    }).bind(app);
-    Object.defineProperty(app, m, { value: newFn });
-  }
-}
-function wooksContext(eventOptions) {
-  return (req, res, next) => {
-    const { store } = eventHttp.createHttpContext({ req, res }, eventOptions || {});
-    store("routeParams").value = new Proxy({}, {
-      get(target, prop, receiver) {
-        return req.params && req.params[prop];
-      }
-    });
-    next();
-  };
-}
+const eventCore = require('@wooksjs/event-core');
 
 class WooksExpress extends eventHttp.WooksHttp {
+  expressApp;
+  expressOpts;
   constructor(expressApp, opts) {
     super(opts);
     this.expressApp = expressApp;
-    this.opts = opts;
-    expressApp.use(this.getServerCb());
+    this.expressOpts = opts ?? {};
+    this.expressApp.use(this.getExpressMiddleware());
   }
+  /**
+   * Start the Express server and return a promise that resolves when listening.
+   */
   listen(...args) {
-    const server = this.server = this.expressApp.listen(...args);
+    const server = this.server = this.expressApp.listen(
+      ...args
+    );
     return new Promise((resolve, reject) => {
-      server.once("listening", resolve);
+      server.once("listening", () => resolve());
       server.once("error", reject);
     });
   }
-  getServerCb() {
-    return async (req, res, next) => {
-      const { restoreCtx, clearCtx } = eventHttp.createHttpContext(
-        { req, res },
-        this.mergeEventOptions(this.opts?.eventOptions)
-      );
-      const { handlers } = this.wooks.lookup(req.method, req.url);
-      if (handlers || this.opts?.onNotFound) {
-        try {
-          await this.processHandlers(handlers || [this.opts?.onNotFound]);
-        } catch (e) {
-          console.error("Internal error, please report: ", e);
-          if (e.stack) {
-            console.warn(e.stack);
+  /**
+   * Returns Express middleware that routes requests through Wooks.
+   * Matched routes are handled by Wooks; unmatched requests call `next()`.
+   */
+  getExpressMiddleware() {
+    const ctxOptions = this.eventContextOptions;
+    const requestLimits = this.expressOpts.requestLimits;
+    const defaultHeaders = this.expressOpts.defaultHeaders;
+    const notFoundHandler = this.expressOpts.onNotFound;
+    const raise404 = this.expressOpts.raise404;
+    return (req, res, next) => {
+      const response = new this.ResponseClass(res, req, ctxOptions.logger, defaultHeaders);
+      const method = req.method || "";
+      const url = req.url || "";
+      eventHttp.createHttpContext(ctxOptions, { req, response, requestLimits }, () => {
+        const ctx = eventCore.current();
+        const handlers = this.wooks.lookupHandlers(method, url, ctx);
+        if (handlers || notFoundHandler) {
+          const result = this.processHandlers(
+            handlers || [notFoundHandler],
+            ctx,
+            response
+          );
+          if (result !== null && result !== void 0 && typeof result.then === "function") {
+            result.catch((error) => {
+              this.logger.error("Internal error, please report", error);
+              this.respond(error, response, ctx);
+            });
           }
-          restoreCtx();
-          this.respond(e);
-          clearCtx();
+          return result;
         }
-      } else {
-        this.logger.debug(
-          `404 Not found (${req.method})${req.url}`
-        );
-        if (this.opts?.raise404) {
-          this.respond(new eventHttp.HttpError(404));
-          clearCtx();
-        } else if (next) {
-          next();
+        if (raise404) {
+          const error = new eventHttp.HttpError(404);
+          this.respond(error, response, ctx);
+          return error;
         }
-      }
+        next();
+      });
     };
   }
 }
 
 exports.WooksExpress = WooksExpress;
-exports.applyExpressAdapter = applyExpressAdapter;

package/dist/index.d.cts

@@ -0,0 +1,53 @@
+import { TWooksHttpOptions, WooksHttp } from '@wooksjs/event-http';
+import { Application, NextFunction } from 'express';
+import { IncomingMessage, ServerResponse } from 'http';
+
+interface TWooksExpressOptions extends TWooksHttpOptions {
+    /**
+     * When true, respond with 404 for unmatched Wooks routes
+     * instead of passing to the next Express middleware.
+     * @default false
+     */
+    raise404?: boolean;
+}
+/**
+ * Express adapter for Wooks.
+ *
+ * Uses Wooks routing and composables on top of an Express application.
+ * Registers itself as Express middleware — requests matching Wooks routes
+ * are handled by Wooks; unmatched requests fall through to Express.
+ *
+ * @example
+ * ```ts
+ * import express from 'express'
+ * import { WooksExpress } from '@wooksjs/express-adapter'
+ * import { useRouteParams } from '@wooksjs/event-http'
+ *
+ * const app = express()
+ * const wooks = new WooksExpress(app)
+ *
+ * wooks.get('/hello/:name', () => {
+ *     const { get } = useRouteParams()
+ *     return { hello: get('name') }
+ * })
+ *
+ * app.listen(3000)
+ * ```
+ */
+declare class WooksExpress extends WooksHttp {
+    protected expressApp: Application;
+    protected expressOpts: TWooksExpressOptions;
+    constructor(expressApp: Application, opts?: TWooksExpressOptions);
+    /**
+     * Start the Express server and return a promise that resolves when listening.
+     */
+    listen(...args: unknown[]): Promise<void>;
+    /**
+     * Returns Express middleware that routes requests through Wooks.
+     * Matched routes are handled by Wooks; unmatched requests call `next()`.
+     */
+    getExpressMiddleware(): (req: IncomingMessage, res: ServerResponse, next: NextFunction) => void;
+}
+
+export { WooksExpress };
+export type { TWooksExpressOptions };

package/dist/index.d.mts

@@ -0,0 +1,53 @@
+import { TWooksHttpOptions, WooksHttp } from '@wooksjs/event-http';
+import { Application, NextFunction } from 'express';
+import { IncomingMessage, ServerResponse } from 'http';
+
+interface TWooksExpressOptions extends TWooksHttpOptions {
+    /**
+     * When true, respond with 404 for unmatched Wooks routes
+     * instead of passing to the next Express middleware.
+     * @default false
+     */
+    raise404?: boolean;
+}
+/**
+ * Express adapter for Wooks.
+ *
+ * Uses Wooks routing and composables on top of an Express application.
+ * Registers itself as Express middleware — requests matching Wooks routes
+ * are handled by Wooks; unmatched requests fall through to Express.
+ *
+ * @example
+ * ```ts
+ * import express from 'express'
+ * import { WooksExpress } from '@wooksjs/express-adapter'
+ * import { useRouteParams } from '@wooksjs/event-http'
+ *
+ * const app = express()
+ * const wooks = new WooksExpress(app)
+ *
+ * wooks.get('/hello/:name', () => {
+ *     const { get } = useRouteParams()
+ *     return { hello: get('name') }
+ * })
+ *
+ * app.listen(3000)
+ * ```
+ */
+declare class WooksExpress extends WooksHttp {
+    protected expressApp: Application;
+    protected expressOpts: TWooksExpressOptions;
+    constructor(expressApp: Application, opts?: TWooksExpressOptions);
+    /**
+     * Start the Express server and return a promise that resolves when listening.
+     */
+    listen(...args: unknown[]): Promise<void>;
+    /**
+     * Returns Express middleware that routes requests through Wooks.
+     * Matched routes are handled by Wooks; unmatched requests call `next()`.
+     */
+    getExpressMiddleware(): (req: IncomingMessage, res: ServerResponse, next: NextFunction) => void;
+}
+
+export { WooksExpress };
+export type { TWooksExpressOptions };

package/dist/index.d.ts

@@ -1,19 +1,53 @@
 import { TWooksHttpOptions, WooksHttp } from '@wooksjs/event-http';
-import Express$1, { Express } from 'express';
-import { Server, IncomingMessage, ServerResponse } from 'http';
-
-declare function applyExpressAdapter(app: Express, eventOptions?: TWooksHttpOptions['eventOptions']): void;
+import { Application, NextFunction } from 'express';
+import { IncomingMessage, ServerResponse } from 'http';
 
+interface TWooksExpressOptions extends TWooksHttpOptions {
+    /**
+     * When true, respond with 404 for unmatched Wooks routes
+     * instead of passing to the next Express middleware.
+     * @default false
+     */
+    raise404?: boolean;
+}
+/**
+ * Express adapter for Wooks.
+ *
+ * Uses Wooks routing and composables on top of an Express application.
+ * Registers itself as Express middleware — requests matching Wooks routes
+ * are handled by Wooks; unmatched requests fall through to Express.
+ *
+ * @example
+ * ```ts
+ * import express from 'express'
+ * import { WooksExpress } from '@wooksjs/express-adapter'
+ * import { useRouteParams } from '@wooksjs/event-http'
+ *
+ * const app = express()
+ * const wooks = new WooksExpress(app)
+ *
+ * wooks.get('/hello/:name', () => {
+ *     const { get } = useRouteParams()
+ *     return { hello: get('name') }
+ * })
+ *
+ * app.listen(3000)
+ * ```
+ */
 declare class WooksExpress extends WooksHttp {
-    protected expressApp: Express$1.Application;
-    protected opts?: (TWooksHttpOptions & {
-        raise404?: boolean | undefined;
-    }) | undefined;
-    constructor(expressApp: Express$1.Application, opts?: (TWooksHttpOptions & {
-        raise404?: boolean | undefined;
-    }) | undefined);
-    listen(...args: Parameters<Server['listen']>): Promise<unknown>;
-    getServerCb(): (req: IncomingMessage, res: ServerResponse, next?: Express$1.NextFunction) => Promise<void>;
+    protected expressApp: Application;
+    protected expressOpts: TWooksExpressOptions;
+    constructor(expressApp: Application, opts?: TWooksExpressOptions);
+    /**
+     * Start the Express server and return a promise that resolves when listening.
+     */
+    listen(...args: unknown[]): Promise<void>;
+    /**
+     * Returns Express middleware that routes requests through Wooks.
+     * Matched routes are handled by Wooks; unmatched requests call `next()`.
+     */
+    getExpressMiddleware(): (req: IncomingMessage, res: ServerResponse, next: NextFunction) => void;
 }
 
-export { WooksExpress, applyExpressAdapter };
+export { WooksExpress };
+export type { TWooksExpressOptions };

package/dist/index.mjs

@@ -1,98 +1,67 @@
-import { createWooksResponder, createHttpContext, useHttpContext, WooksHttp, HttpError } from '@wooksjs/event-http';
-
-const methods = [
-  "get",
-  "post",
-  "delete",
-  "put",
-  "patch",
-  "options",
-  "head",
-  "all"
-];
-function applyExpressAdapter(app, eventOptions) {
-  const responder = createWooksResponder();
-  function useWooksDecorator(fn) {
-    return async () => {
-      const { restoreCtx, clearCtx } = useHttpContext();
-      try {
-        const result = await fn();
-        restoreCtx();
-        await responder.respond(result);
-      } catch (e) {
-        restoreCtx();
-        await responder.respond(e);
-      }
-      clearCtx();
-    };
-  }
-  app.use(wooksContext(eventOptions));
-  for (const m of methods) {
-    const defFn = app[m].bind(app);
-    const newFn = ((...args) => {
-      return defFn(...args.map((a) => typeof a === "function" ? useWooksDecorator(a) : a));
-    }).bind(app);
-    Object.defineProperty(app, m, { value: newFn });
-  }
-}
-function wooksContext(eventOptions) {
-  return (req, res, next) => {
-    const { store } = createHttpContext({ req, res }, eventOptions || {});
-    store("routeParams").value = new Proxy({}, {
-      get(target, prop, receiver) {
-        return req.params && req.params[prop];
-      }
-    });
-    next();
-  };
-}
+import { WooksHttp, createHttpContext, HttpError } from '@wooksjs/event-http';
+import { current } from '@wooksjs/event-core';
 
 class WooksExpress extends WooksHttp {
+  expressApp;
+  expressOpts;
   constructor(expressApp, opts) {
     super(opts);
     this.expressApp = expressApp;
-    this.opts = opts;
-    expressApp.use(this.getServerCb());
+    this.expressOpts = opts ?? {};
+    this.expressApp.use(this.getExpressMiddleware());
   }
+  /**
+   * Start the Express server and return a promise that resolves when listening.
+   */
   listen(...args) {
-    const server = this.server = this.expressApp.listen(...args);
+    const server = this.server = this.expressApp.listen(
+      ...args
+    );
     return new Promise((resolve, reject) => {
-      server.once("listening", resolve);
+      server.once("listening", () => resolve());
       server.once("error", reject);
     });
   }
-  getServerCb() {
-    return async (req, res, next) => {
-      const { restoreCtx, clearCtx } = createHttpContext(
-        { req, res },
-        this.mergeEventOptions(this.opts?.eventOptions)
-      );
-      const { handlers } = this.wooks.lookup(req.method, req.url);
-      if (handlers || this.opts?.onNotFound) {
-        try {
-          await this.processHandlers(handlers || [this.opts?.onNotFound]);
-        } catch (e) {
-          console.error("Internal error, please report: ", e);
-          if (e.stack) {
-            console.warn(e.stack);
+  /**
+   * Returns Express middleware that routes requests through Wooks.
+   * Matched routes are handled by Wooks; unmatched requests call `next()`.
+   */
+  getExpressMiddleware() {
+    const ctxOptions = this.eventContextOptions;
+    const requestLimits = this.expressOpts.requestLimits;
+    const defaultHeaders = this.expressOpts.defaultHeaders;
+    const notFoundHandler = this.expressOpts.onNotFound;
+    const raise404 = this.expressOpts.raise404;
+    return (req, res, next) => {
+      const response = new this.ResponseClass(res, req, ctxOptions.logger, defaultHeaders);
+      const method = req.method || "";
+      const url = req.url || "";
+      createHttpContext(ctxOptions, { req, response, requestLimits }, () => {
+        const ctx = current();
+        const handlers = this.wooks.lookupHandlers(method, url, ctx);
+        if (handlers || notFoundHandler) {
+          const result = this.processHandlers(
+            handlers || [notFoundHandler],
+            ctx,
+            response
+          );
+          if (result !== null && result !== void 0 && typeof result.then === "function") {
+            result.catch((error) => {
+              this.logger.error("Internal error, please report", error);
+              this.respond(error, response, ctx);
+            });
           }
-          restoreCtx();
-          this.respond(e);
-          clearCtx();
+          return result;
         }
-      } else {
-        this.logger.debug(
-          `404 Not found (${req.method})${req.url}`
-        );
-        if (this.opts?.raise404) {
-          this.respond(new HttpError(404));
-          clearCtx();
-        } else if (next) {
-          next();
+        if (raise404) {
+          const error = new HttpError(404);
+          this.respond(error, response, ctx);
+          return error;
         }
-      }
+        next();
+      });
     };
   }
 }
 
-export { WooksExpress, applyExpressAdapter };
+export { WooksExpress };

package/package.json

@@ -1,98 +1,70 @@
 {
   "name": "@wooksjs/express-adapter",
-  "version": "0.4.9",
-  "description": "Express Adapter for Wooks Composables",
-  "main": "dist/index.cjs",
-  "module": "dist/index.mjs",
-  "types": "dist/index.d.ts",
-  "files": [
-    "dist"
+  "version": "0.7.0",
+  "description": "Express Adapter for Wooks — use Wooks composables with Express",
+  "keywords": [
+    "adapter",
+    "api",
+    "app",
+    "composables",
+    "express",
+    "framework",
+    "http",
+    "rest",
+    "restful",
+    "web",
+    "wooks"
   ],
-  "scripts": {
-    "build": "unbuild",
-    "release": "node ./scripts/release",
-    "test": "jest --runInBand",
-    "test:cov": "jest --runInBand --coverage",
-    "lint": "eslint --ext .ts src/**/**.ts",
-    "changelog": "conventional-changelog -p angular -i CHANGELOG.md -s",
-    "version": "conventional-changelog -p angular -i CHANGELOG.md -s && git add CHANGELOG.md"
+  "homepage": "https://github.com/wooksjs/express-adapter#readme",
+  "bugs": {
+    "url": "https://github.com/wooksjs/express-adapter/issues"
   },
+  "license": "MIT",
+  "author": "Artem Maltsev",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/wooksjs/express-adapter.git"
   },
+  "files": [
+    "dist"
+  ],
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
   "exports": {
     ".": {
-      "node": {
-        "default": "./dist/index.mjs",
-        "require": "./dist/index.cjs",
-        "import": "./dist/index.mjs",
-        "types": "./dist/index.d.ts"
-      },
-      "default": "./dist/index.mjs",
-      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
-      "types": "./dist/index.d.ts"
+      "require": "./dist/index.cjs"
     }
   },
-  "keywords": [
-    "http",
-    "wooks",
-    "composables",
-    "express",
-    "adapter",
-    "web",
-    "framework",
-    "app",
-    "api",
-    "rest",
-    "restful",
-    "prostojs"
-  ],
-  "buildOptions": {
-    "formats": [
-      "esm-bundler",
-      "cjs"
-    ]
-  },
-  "gitHooks": {
-    "commit-msg": "node scripts/verifyCommit.js"
-  },
-  "author": "Artem Maltsev",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/wooksjs/express-adapter/issues"
+  "devDependencies": {
+    "@types/express": "^5.0.0",
+    "@types/node": "^22.0.0",
+    "@wooksjs/event-core": "^0.7.4",
+    "@wooksjs/event-http": "^0.7.4",
+    "express": "^5.0.0",
+    "oxfmt": "^0.35.0",
+    "oxlint": "^1.50.0",
+    "typescript": "^5.7.0",
+    "unbuild": "^3.5.0",
+    "vitest": "^3.0.0",
+    "wooks": "^0.7.4"
   },
-  "homepage": "https://github.com/wooksjs/express-adapter#readme",
   "peerDependencies": {
-    "@wooksjs/event-http": "^0.4.8",
-    "wooks": "^0.4.8",
-    "express": "^4.0.0"
+    "@wooksjs/event-core": ">=0.7.0",
+    "@wooksjs/event-http": ">=0.7.0",
+    "express": ">=4.0.0",
+    "wooks": ">=0.7.0"
   },
-  "devDependencies": {
-    "@prostojs/dye": "^0.3.0",
-    "@types/express": "^4.17.14",
-    "@types/jest": "^29.2.0",
-    "@types/node": "^18.11.0",
-    "@typescript-eslint/eslint-plugin": "^5.42.0",
-    "@typescript-eslint/parser": "^5.0.0",
-    "@wooksjs/event-http": "^0.4.8",
-    "@wooksjs/http-body": "^0.4.8",
-    "conventional-changelog": "^3.1.24",
-    "conventional-changelog-cli": "^2.1.1",
-    "enquirer": "^2.3.6",
-    "eslint": "^7.32.0",
-    "eslint-config-prettier": "^8.3.0",
-    "eslint-plugin-import": "^2.24.2",
-    "execa": "^5.1.1",
-    "express": "^4.18.2",
-    "jest": "^29.2.2",
-    "minimist": "^1.2.6",
-    "semver": "^7.3.5",
-    "ts-jest": "^29.0.3",
-    "tslib": "^2.4.1",
-    "typescript": "^4.8.4",
-    "unbuild": "^0.9.4",
-    "yorkie": "^2.0.0"
+  "scripts": {
+    "build": "unbuild",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:cov": "vitest run --coverage",
+    "lint": "oxlint",
+    "lint:fix": "oxlint --fix",
+    "fmt": "oxfmt",
+    "fmt:check": "oxfmt --check"
   }
-}
+}