adorn-api 1.0.0 → 1.0.2

package/README.md

@@ -1,249 +1,54 @@
-# Adorn API
-
-A TypeScript API framework using **Standard TC39 Decorators** (not experimental decorators) to build type-safe, self-documenting APIs with automatic OpenAPI/Swagger generation.
-
-## Features
-
-- ✅ **Standard Decorators**: Uses TC39 Stage 3 decorators (no experimental flags needed)
-- ✅ **Type-Safe DTOs**: Full TypeScript type checking at edit time
-- ✅ **Automatic Swagger Generation**: Generates OpenAPI 3.0 documentation from your code
-- ✅ **Runtime Route Generation**: Automatically creates Express routes
-- ✅ **Inheritance Support**: Extend base DTO classes with full type information
-- ✅ **Generic Response Types**: `EntityResponse<T>`, `CreateInput<T>`, etc.
-- ✅ **Authentication**: Built-in `@Authorized` decorator
-- ✅ **Union Types & Enums**: Automatically converted to Swagger enums
-- ✅ **Nested Objects**: Recursive type resolution for complex DTOs
-
-## Installation
-
-```bash
-npm install adorn-api
-```
-
-## Quick Start
-
-### 1. Create a Controller
-
-```typescript
-// src/controllers/user.controller.ts
-import { Controller, Get, Post, FromQuery, FromPath, FromBody } from "adorn-api";
-
-class GetUserRequest {
-  @FromPath()
-  userId!: string;
-  
-  @FromQuery()
-  details?: boolean;
-}
-
-@Controller("users")
-export class UserController {
-  @Get("/{userId}")
-  public async getUser(req: GetUserRequest): Promise<string> {
-    return `Getting user ${req.userId} with details: ${req.details}`;
-  }
-}
-```
-
-### 2. Generate Swagger and Routes
-
-```bash
-npx adorn-api gen
-```
-
-This generates:
-- `swagger.json` - OpenAPI 3.0 specification
-- `src/routes.ts` - Express route handlers
-
-### 3. Start Your Server
-
-```typescript
-// src/server.ts
-import express from "express";
-import { RegisterRoutes } from "./routes.js";
-
-const app = express();
-app.use(express.json());
-
-RegisterRoutes(app);
-
-app.listen(3000, () => {
-  console.log("Server running on http://localhost:3000");
-});
-```
-
-Visit http://localhost:3000/docs to see your Swagger UI.
-
-## Advanced Usage
-
-### Inheritance & Generics
-
-```typescript
-import { PaginationQuery, EntityResponse, CreateInput } from "../lib/common.js";
-
-// Inherit pagination properties
-class UserListRequest extends PaginationQuery {
-  search?: string; 
-  
-  @FromPath()
-  tenantId!: string;
-}
-
-// Use generic type helpers
-class CreateUserDto implements CreateInput<User, 'name' | 'email'> {
-  @FromBody()
-  name!: string;
-
-  @FromBody()
-  email!: string;
-}
-
-@Controller("advanced")
-export class AdvancedController {
-  @Get("/{tenantId}/users")
-  public async listUsers(req: UserListRequest): Promise<EntityResponse<User[]>> {
-    return [/* ... */];
-  }
-}
-```
-
-### Authentication
-
-```typescript
-import { Authorized } from "../lib/decorators.js";
-
-@Controller("profile")
-export class ProfileController {
-  @Authorized("admin")
-  @Post("/update")
-  public async update(req: UpdateProfileDto) {
-    // Only accessible with valid Bearer token
-    return { success: true };
-  }
-}
-```
-
-## Project Structure
-
-```
-adorn-api/
-├── src/
-│   ├── lib/
-│   │   ├── decorators.ts      # Standard decorators (@Get, @Post, @Controller, etc.)
-│   │   └── common.ts          # Common types (PaginationQuery, EntityResponse, etc.)
-│   ├── cli/
-│   │   ├── generate-swagger.ts # Swagger/OpenAPI generator
-│   │   └── generate-routes.ts  # Express route generator
-│   └── index.ts               # Main library entry point
-├── tests/
-│   └── example-app/           # Example application using adorn-api
-│       ├── controllers/       # Example controllers
-│       ├── entities/          # Example entities
-│       ├── middleware/        # Example middleware
-│       ├── routes.ts         # Generated routes (auto-generated)
-│       └── server.ts         # Example Express server
-├── swagger.json              # Generated OpenAPI spec
-└── package.json
-```
-
-## Development
-
-### Available Scripts
-
-- `npm run build` - Compile TypeScript to JavaScript
-- `npm run gen:spec` - Generate Swagger documentation only
-- `npm run gen:routes` - Generate Express routes only
-- `npm run gen` - Generate both Swagger and routes
-- `npm run example` - Run the example application
-
-### Testing the Library
-
-```bash
-# Generate from example app
-npm run gen
-
-# Run the example server
-npm run example
-```
-
-## How It Works
-
-### 1. Decorators (src/lib/decorators.ts)
-
-Uses **Standard TC39 Decorators** with `context.addInitializer()` to attach metadata:
-
-```typescript
-export function Get(path: string) {
-  return function (originalMethod: any, context: ClassMethodDecoratorContext) {
-    context.addInitializer(function () {
-      // Store route metadata
-      const routes = (this as any)[META_KEY] || [];
-      routes.push({ method: 'get', path, methodName: String(context.name) });
-      (this as any)[META_KEY] = routes;
-    });
-    return originalMethod;
-  };
-}
-```
-
-### 2. Swagger Generator (src/cli/generate-swagger.ts)
-
-Uses **ts-morph** to statically analyze TypeScript code:
-
-- Parses `@Controller` and `@Get`/`@Post` decorators
-- Resolves DTO types including inheritance and generics
-- Converts TypeScript types to JSON Schema
-- Handles union types (enums), nested objects, and Promise unwrapping
-- Generates OpenAPI 3.0 specification
-
-### 3. Route Generator (src/cli/generate-routes.ts)
-
-Generates actual Express route handlers:
-
-```typescript
-// Generated code in src/routes.ts
-app.get('/users/:userId', async (req: Request, res: Response) => {
-    const controller = new UserController();
-    const input: any = {};
-    Object.assign(input, req.query);
-    Object.assign(input, req.params);
-    Object.assign(input, req.body);
-    
-    const response = await controller.getUser(input);
-    res.status(200).json(response);
-});
-```
-
-## Why Standard Decorators?
-
-1. **Future-Proof**: Uses the official TC39 decorator proposal (Stage 3)
-2. **No Experimental Flags**: Works with `"experimentalDecorators": false`
-3. **Better Type Safety**: Leverages TypeScript's type system instead of runtime reflection
-4. **Cleaner API**: Single-parameter DTO pattern is more explicit than parameter decorators
-
-## Comparison with tsoa
-
-| Feature | tsoa (Legacy) | adorn-api |
-|---------|---------------|-----------|
-| Decorators | Experimental (`emitDecoratorMetadata`) | Standard TC39 |
-| Parameter Decorators | `@Body() body: string` | DTO classes with `@FromBody()` |
-| Type Safety | Runtime reflection | Edit-time type checking |
-| Inheritance | Limited | Full support |
-| Generics | Complex | Native TypeScript |
-| Future Compatibility | Deprecated in future TS | Officially supported |
-
-## Next Steps
-
-To make this production-ready:
-
-1. **Validation**: Integrate Zod or class-validator in the route generator
-2. **Error Handling**: Add centralized error handling middleware
-3. **Database Integration**: Add ORM support (Prisma, TypeORM, etc.)
-4. **Testing**: Add unit and integration test utilities
-5. **CORS**: Add CORS configuration
-6. **Rate Limiting**: Add rate limiting middleware
-7. **Logging**: Add structured logging (Winston, Pino)
-
-## License
-
-ISC
+# Adorn API
+Adorn API turns TypeScript classes into HTTP controllers with Stage-3 decorators, then wires Express routes, validation, and OpenAPI docs from the same metadata. It stays small and focused while still supporting MetalORM-backed persistence when you want it.
+
+## Why Adorn API
+- One source of truth: decorators and schemas drive routing, validation, and OpenAPI.
+- Express-native by default, without locking you into a large framework.
+- MetalORM helpers keep DTOs, filters, and entities in sync.
+- Test-first ergonomics with clear e2e coverage of the runtime wiring.
+
+## Features
+- Controller decorators (`@Controller`, `@Get`, `@Post`, etc.) backed by a registry/router that mounts on Express.
+- `createAdornExpressRouter` and `buildRegistry` for mounting Adorn into existing Express stacks.
+- Problem Details error handling with an `onError` hook for custom shapes/logging.
+- Built-in OpenAPI generator with optional Swagger UI serving through the Express adapter.
+- MetalORM helpers (`entityDto`, `filtersFromEntity`, `tableDefOf`) to reuse entity metadata for payload validation and database filtering.
+- End-to-end coverage for both direct API handlers and MetalORM REST routes using Vitest + Supertest.
+
+For detailed writeups of each feature, see the companion guides under `docs/` (including the Stage-3 decorator setup).
+
+## Requirements
+- Node.js v18+
+- SQLite (only for in-memory tests; runtime persistence is pluggable via MetalORM executors)
+- TypeScript 5.x with Stage-3 decorators (do not enable `experimentalDecorators`)
+
+## Getting started
+1. `npm install` to pull runtime and dev dependencies (Express, MetalORM, Vitest).
+2. `npm run build` to compile the TypeScript sources into `dist/`.
+3. `npm run test` to run the full Vitest suite (unit + integration/e2e tests).
+
+For quick feedback on a single spec file: `npm run test -- test/e2e/metal-orm.adorn-api.rest.spec.ts`.
+
+## Scripts
+- `npm run clean`: removes the `dist` directory.
+- `npm run build`: transpiles `src/**/*.ts` via the `tsconfig.build.json` bundle target.
+- `npm run typecheck`: runs `tsc` with strict settings against `src` + `test`.
+- `npm run check`: runs the decorated-return contract check plus the test suite.
+- `npm run test` / `npm run test:e2e`: run the entire Vitest suite or just the e2e directory.
+
+## MetalORM integration
+- Controllers create `OrmSession` instances with a shared in-memory SQLite executor for tests.
+- DTOs and filter schemas derive directly from `metal-orm` entity definitions via helpers in `src/integrations/metal-orm/schema`.
+- The REST controller examples show how to load entities via `selectFromEntity`, update tracked instances, and rely on `OrmSession` flush/commit semantics without manually writing SQL.
+
+Learn more about MetalORM on npm: https://www.npmjs.com/package/metal-orm
+
+## Project layout
+- `src/`: exports glue code (`express`, `metal-orm`, validation helpers, adapters).
+- `test/e2e/`: Vitest suites exercising the Express and MetalORM API surface.
+- `src/types/metal-orm.d.ts`: local type definitions used while the shared MetalORM package upgrades.
+
+## Next steps
+1. Add real decorators and metadata for your domain models under `src`.
+2. Extend `src/adapters/express` to add middleware or transports as needed.
+3. Hook a persistent MetalORM executor when moving beyond the in-memory SQLite setup used in tests.

package/dist/adapters/express/createApp.d.ts

@@ -0,0 +1,158 @@
+import { type Express, type Router } from 'express';
+import type { ControllerCtor, Registry } from '../../core/registry/types.js';
+import type { Validator } from '../../contracts/validator.js';
+import { type ApplyRoutesOptions } from './router.js';
+import { type AdornErrorHandlerOptions } from './middleware/errorHandler.js';
+import type { OpenApiBuildOptions } from '../../core/openapi/buildOpenApi.js';
+/**
+ * Options for OpenAPI documentation generation and serving.
+ * Extends OpenApiBuildOptions with serving configuration.
+ */
+export type AdornOpenApiOptions = OpenApiBuildOptions & {
+    /** Whether to enable OpenAPI documentation (default: true) */
+    enabled?: boolean;
+    /** Path to serve the OpenAPI JSON specification (default: '/openapi.json') */
+    jsonPath?: string;
+    /** Path to serve the OpenAPI documentation UI (default: '/docs') */
+    docsPath?: string;
+    /** Whether to serve Swagger UI (default: true) */
+    swaggerUi?: boolean;
+    /** Configuration options for Swagger UI */
+    swaggerUiConfig?: Record<string, unknown>;
+};
+/**
+ * Options for creating an Adorn Express router with controllers.
+ *
+ * @see ApplyRoutesOptions for additional routing options
+ */
+export type CreateAdornExpressRouterOptions = ApplyRoutesOptions & {
+    /** Array of controller constructors to register */
+    controllers: ControllerCtor[];
+    /** Whether to automatically add JSON body parser middleware (default: true) */
+    jsonBodyParser?: boolean;
+    /** Validator instance for request validation */
+    validator?: Validator;
+    /** Error handler configuration or false to disable (default: built-in handler) */
+    errorHandler?: AdornErrorHandlerOptions | false;
+    /** OpenAPI documentation configuration */
+    openapi?: AdornOpenApiOptions;
+};
+/**
+ * Result of creating an Adorn Express router.
+ */
+export type CreateAdornExpressRouterResult = {
+    /** Configured Express router with all routes */
+    router: Router;
+    /** Route registry containing metadata about all registered routes */
+    registry: Registry;
+};
+/**
+ * Options for creating an Adorn Express application.
+ * Extends router options with mount path configuration.
+ *
+ * @see CreateAdornExpressRouterOptions for base options
+ */
+export type CreateAdornExpressAppOptions = CreateAdornExpressRouterOptions & {
+    /** Path to mount the router (default: '/') */
+    mountPath?: string;
+};
+/**
+ * Creates a complete Express application with Adorn API functionality.
+ *
+ * This function sets up an Express app with all Adorn features including:
+ * - Controller-based routing
+ * - Automatic OpenAPI documentation
+ * - Built-in error handling
+ * - Request validation
+ *
+ * @param options - Configuration options for the application
+ * @returns Configured Express application instance
+ *
+ * @example
+ * ```typescript
+ * import { createAdornExpressApp } from '@adorn/api';
+ * import { UserController } from './controllers/user.controller';
+ *
+ * const app = createAdornExpressApp({
+ *   controllers: [UserController],
+ *   openapi: {
+ *     title: 'My API',
+ *     version: '1.0.0'
+ *   }
+ * });
+ *
+ * app.listen(3000, () => {
+ *   console.log('Server running on port 3000');
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With custom mount path
+ * const app = createAdornExpressApp({
+ *   controllers: [UserController, ProductController],
+ *   mountPath: '/api/v1',
+ *   jsonBodyParser: true,
+ *   errorHandler: {
+ *     logErrors: true,
+ *     exposeStack: process.env.NODE_ENV === 'development'
+ *   }
+ * });
+ * ```
+ *
+ * @see createAdornExpressRouter for router-specific functionality
+ * @see AdornOpenApiOptions for OpenAPI configuration
+ */
+export declare function createAdornExpressApp(options: CreateAdornExpressAppOptions): Express;
+/**
+ * Creates an Express router with Adorn API functionality.
+ *
+ * This function sets up an Express router with all Adorn features including:
+ * - Controller-based routing
+ * - Automatic OpenAPI documentation
+ * - Built-in error handling
+ * - Request validation
+ *
+ * @param options - Configuration options for the router
+ * @returns Object containing the configured router and route registry
+ *
+ * @example
+ * ```typescript
+ * import { createAdornExpressRouter } from '@adorn/api';
+ * import { UserController } from './controllers/user.controller';
+ * import express from 'express';
+ *
+ * const app = express();
+ * const { router, registry } = createAdornExpressRouter({
+ *   controllers: [UserController],
+ *   openapi: {
+ *     title: 'My API',
+ *     version: '1.0.0',
+ *     docsPath: '/api-docs'
+ *   }
+ * });
+ *
+ * app.use('/api', router);
+ *
+ * // Access the registry for runtime inspection
+ * console.log('Registered routes:', registry.routes.length);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With custom validator and error handling
+ * const { router } = createAdornExpressRouter({
+ *   controllers: [UserController],
+ *   validator: new CustomValidator(),
+ *   errorHandler: {
+ *     logErrors: true,
+ *     customErrorFormatter: (err) => ({ ...err, timestamp: new Date() })
+ *   }
+ * });
+ * ```
+ *
+ * @see createAdornExpressApp for full application setup
+ * @see AdornOpenApiOptions for OpenAPI configuration
+ */
+export declare function createAdornExpressRouter(options: CreateAdornExpressRouterOptions): CreateAdornExpressRouterResult;
+//# sourceMappingURL=createApp.d.ts.map

package/dist/adapters/express/createApp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createApp.d.ts","sourceRoot":"","sources":["../../../src/adapters/express/createApp.ts"],"names":[],"mappings":"AAAA,OAAgB,EAAE,KAAK,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,SAAS,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAC7E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAE9D,OAAO,EAAgC,KAAK,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACpF,OAAO,EAGL,KAAK,wBAAwB,EAC9B,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAG9E;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,mBAAmB,GAAG;IACtD,8DAA8D;IAC9D,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oEAAoE;IACpE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,kDAAkD;IAClD,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,2CAA2C;IAC3C,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC3C,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,+BAA+B,GAAG,kBAAkB,GAAG;IACjE,mDAAmD;IACnD,WAAW,EAAE,cAAc,EAAE,CAAC;IAC9B,+EAA+E;IAC/E,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,gDAAgD;IAChD,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,kFAAkF;IAClF,YAAY,CAAC,EAAE,wBAAwB,GAAG,KAAK,CAAC;IAChD,0CAA0C;IAC1C,OAAO,CAAC,EAAE,mBAAmB,CAAC;CAC/B,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,8BAA8B,GAAG;IAC3C,gDAAgD;IAChD,MAAM,EAAE,MAAM,CAAC;IACf,qEAAqE;IACrE,QAAQ,EAAE,QAAQ,CAAC;CACpB,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,4BAA4B,GAAG,+BAA+B,GAAG;IAC3E,8CAA8C;IAC9C,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,4BAA4B,GAAG,OAAO,CAKpF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,+BAA+B,GACvC,8BAA8B,CAqChC"}

package/dist/adapters/express/createApp.js

@@ -0,0 +1,141 @@
+import express, {} from 'express';
+import { buildRegistry } from '../../core/registry/buildRegistry.js';
+import { applyRegistryToExpressRouter } from './router.js';
+import { adornErrorHandler, createAdornExpressErrorHandler, } from './middleware/errorHandler.js';
+import { serveOpenApi } from './swagger/serve.js';
+/**
+ * Creates a complete Express application with Adorn API functionality.
+ *
+ * This function sets up an Express app with all Adorn features including:
+ * - Controller-based routing
+ * - Automatic OpenAPI documentation
+ * - Built-in error handling
+ * - Request validation
+ *
+ * @param options - Configuration options for the application
+ * @returns Configured Express application instance
+ *
+ * @example
+ * ```typescript
+ * import { createAdornExpressApp } from '@adorn/api';
+ * import { UserController } from './controllers/user.controller';
+ *
+ * const app = createAdornExpressApp({
+ *   controllers: [UserController],
+ *   openapi: {
+ *     title: 'My API',
+ *     version: '1.0.0'
+ *   }
+ * });
+ *
+ * app.listen(3000, () => {
+ *   console.log('Server running on port 3000');
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With custom mount path
+ * const app = createAdornExpressApp({
+ *   controllers: [UserController, ProductController],
+ *   mountPath: '/api/v1',
+ *   jsonBodyParser: true,
+ *   errorHandler: {
+ *     logErrors: true,
+ *     exposeStack: process.env.NODE_ENV === 'development'
+ *   }
+ * });
+ * ```
+ *
+ * @see createAdornExpressRouter for router-specific functionality
+ * @see AdornOpenApiOptions for OpenAPI configuration
+ */
+export function createAdornExpressApp(options) {
+    const app = express();
+    const { router } = createAdornExpressRouter(options);
+    app.use(options.mountPath ?? '/', router);
+    return app;
+}
+/**
+ * Creates an Express router with Adorn API functionality.
+ *
+ * This function sets up an Express router with all Adorn features including:
+ * - Controller-based routing
+ * - Automatic OpenAPI documentation
+ * - Built-in error handling
+ * - Request validation
+ *
+ * @param options - Configuration options for the router
+ * @returns Object containing the configured router and route registry
+ *
+ * @example
+ * ```typescript
+ * import { createAdornExpressRouter } from '@adorn/api';
+ * import { UserController } from './controllers/user.controller';
+ * import express from 'express';
+ *
+ * const app = express();
+ * const { router, registry } = createAdornExpressRouter({
+ *   controllers: [UserController],
+ *   openapi: {
+ *     title: 'My API',
+ *     version: '1.0.0',
+ *     docsPath: '/api-docs'
+ *   }
+ * });
+ *
+ * app.use('/api', router);
+ *
+ * // Access the registry for runtime inspection
+ * console.log('Registered routes:', registry.routes.length);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With custom validator and error handling
+ * const { router } = createAdornExpressRouter({
+ *   controllers: [UserController],
+ *   validator: new CustomValidator(),
+ *   errorHandler: {
+ *     logErrors: true,
+ *     customErrorFormatter: (err) => ({ ...err, timestamp: new Date() })
+ *   }
+ * });
+ * ```
+ *
+ * @see createAdornExpressApp for full application setup
+ * @see AdornOpenApiOptions for OpenAPI configuration
+ */
+export function createAdornExpressRouter(options) {
+    const router = express.Router();
+    if (options.jsonBodyParser ?? true) {
+        router.use(express.json());
+    }
+    const registry = buildRegistry(options.controllers);
+    applyRegistryToExpressRouter(router, registry, options);
+    const oa = options.openapi;
+    if (oa?.enabled ?? true) {
+        if (oa?.title && oa?.version) {
+            const openApiOptions = {
+                title: oa.title,
+                version: oa.version,
+                ...(oa.servers !== undefined ? { servers: oa.servers } : {}),
+            };
+            const serveOptions = {
+                ...(oa.jsonPath !== undefined ? { jsonPath: oa.jsonPath } : {}),
+                ...(oa.docsPath !== undefined ? { docsPath: oa.docsPath } : {}),
+                ...(oa.swaggerUi !== undefined ? { swaggerUi: oa.swaggerUi } : {}),
+                ...(oa.swaggerUiConfig !== undefined ? { swaggerUiConfig: oa.swaggerUiConfig } : {}),
+            };
+            router.use(serveOpenApi(registry, openApiOptions, serveOptions));
+        }
+    }
+    if (options.errorHandler !== false) {
+        const handler = options.errorHandler
+            ? createAdornExpressErrorHandler(options.errorHandler)
+            : adornErrorHandler;
+        router.use(handler);
+    }
+    return { router, registry };
+}
+//# sourceMappingURL=createApp.js.map

package/dist/adapters/express/createApp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createApp.js","sourceRoot":"","sources":["../../../src/adapters/express/createApp.ts"],"names":[],"mappings":"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"}

package/dist/adapters/express/index.d.ts

@@ -0,0 +1,7 @@
+export * from './createApp.js';
+export * from './router.js';
+export * from './transport/request.js';
+export * from './transport/response.js';
+export * from './middleware/errorHandler.js';
+export * from './swagger/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/adapters/express/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/adapters/express/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,oBAAoB,CAAC"}

package/dist/adapters/express/index.js

@@ -0,0 +1,7 @@
+export * from './createApp.js';
+export * from './router.js';
+export * from './transport/request.js';
+export * from './transport/response.js';
+export * from './middleware/errorHandler.js';
+export * from './swagger/index.js';
+//# sourceMappingURL=index.js.map

package/dist/adapters/express/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/adapters/express/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,oBAAoB,CAAC"}