adorn-api 1.0.0

package/README.md

@@ -0,0 +1,249 @@
+# 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

package/dist/cli/generate-routes.js

@@ -0,0 +1,101 @@
+// src/cli/generate-routes.ts
+import { Project } from "ts-morph";
+import * as fs from "fs";
+const PROJECT_ROOT = "./tsconfig.json";
+const OUTPUT_FILE = "./src/routes.ts"; // We generate this file!
+const project = new Project({ tsConfigFilePath: PROJECT_ROOT });
+let routeCode = `/* tslint:disable */
+/* eslint-disable */
+// WARNING: This file was auto-generated by adorn-api. Do not edit.
+import { Express, Request, Response } from 'express';
+`;
+// Helper to keep track of imports we need to add to the generated file
+const imports = new Set();
+function processController(classDec) {
+    const className = classDec.getName();
+    if (!className)
+        return "";
+    // Track import (assuming controllers are in ./controllers/)
+    const sourceFile = classDec.getSourceFile();
+    const baseName = sourceFile.getBaseName().replace('.ts', '.js');
+    const relativePath = sourceFile.getDirectoryPath().replace(process.cwd() + "/src", ".");
+    imports.add(`import { ${className} } from '${relativePath}/${baseName}';`);
+    const controllerDec = classDec.getDecorators().find(d => d.getName() === "Controller");
+    if (!controllerDec)
+        return "";
+    const basePath = controllerDec.getArguments()[0]?.getText().replace(/['"]/g, "") || "/";
+    let methodBlocks = "";
+    classDec.getMethods().forEach(method => {
+        const getDec = method.getDecorator("Get");
+        const postDec = method.getDecorator("Post");
+        const putDec = method.getDecorator("Put");
+        const deleteDec = method.getDecorator("Delete");
+        const decorator = getDec || postDec || putDec || deleteDec;
+        if (!decorator)
+            return;
+        const httpMethod = getDec ? "get" : postDec ? "post" : putDec ? "put" : "delete";
+        const pathArg = decorator.getArguments()[0]?.getText().replace(/['"]/g, "") || "/";
+        const fullPath = `/${basePath}${pathArg}`.replace("//", "/").replace(/{/g, ":").replace(/}/g, ""); // Convert {id} to :id for Express
+        const methodName = method.getName();
+        const params = method.getParameters();
+        // Authentication check
+        const authDec = method.getDecorator("Authorized");
+        const controllerAuthDec = classDec.getDecorator("Authorized");
+        const hasAuth = !!authDec || !!controllerAuthDec;
+        const middlewareArgs = hasAuth ? "authenticationMiddleware, " : "";
+        // Logic to instantiate the DTO
+        let paramInstantiation = "";
+        if (params.length > 0) {
+            const paramName = params[0].getName();
+            const paramType = params[0].getType().getSymbol()?.getName();
+            // We assume the DTO is a class we can instantiate, or a shape we construct
+            // Here we map request parts to the DTO
+            paramInstantiation = `
+        const input: any = {};
+        // Map Query
+        Object.assign(input, req.query);
+        // Map Params
+        Object.assign(input, req.params);
+        // Map Body
+        Object.assign(input, req.body);
+        
+        // In a real app, you would run 'zod' or 'class-validator' here on 'input'
+      `;
+        }
+        methodBlocks += `
+    app.${httpMethod}('${fullPath}', ${middlewareArgs}async (req: Request, res: Response) => {
+        const controller = new ${className}();
+        try {
+            ${paramInstantiation}
+            const response = await controller.${methodName}(${params.length > 0 ? 'input' : ''});
+            res.status(200).json(response);
+        } catch (err: any) {
+            console.error(err);
+            res.status(500).send(err.message);
+        }
+    });
+    `;
+    });
+    return methodBlocks;
+}
+const sourceFiles = project.getSourceFiles("src/controllers/**/*.ts");
+let allRoutes = "";
+sourceFiles.forEach(file => {
+    file.getClasses().forEach(c => {
+        allRoutes += processController(c);
+    });
+});
+// Add authentication middleware import if needed
+if (allRoutes.includes('authenticationMiddleware')) {
+    routeCode += `import { authenticationMiddleware } from './middleware/auth.middleware.js';\n`;
+}
+// Prepend imports
+routeCode += Array.from(imports).join('\n');
+routeCode += `
+
+export function RegisterRoutes(app: Express) {
+    ${allRoutes}
+}
+`;
+fs.writeFileSync(OUTPUT_FILE, routeCode);
+console.log(`✅ Generated Routes at ${OUTPUT_FILE}`);

package/dist/cli/generate-swagger.js

@@ -0,0 +1,197 @@
+// src/cli/generate-swagger.ts
+import { Project, SyntaxKind } from "ts-morph";
+import * as fs from "fs";
+const PROJECT_ROOT = "./tsconfig.json";
+const OUTPUT_FILE = "./swagger.json";
+const project = new Project({ tsConfigFilePath: PROJECT_ROOT });
+const openApiSpec = {
+    openapi: "3.0.0",
+    info: { title: "Adorn API", version: "2.0.0" },
+    paths: {},
+    components: {
+        schemas: {},
+        securitySchemes: {
+            bearerAuth: {
+                type: "http",
+                scheme: "bearer",
+                bearerFormat: "JWT"
+            }
+        }
+    },
+};
+// --- Helper: Deep Type Resolver ---
+// This converts TypeScript Types (Generics, Interfaces, Primitives) into JSON Schema
+function resolveSchema(type, collectedSchemas) {
+    // 1. Handle Primitives
+    if (type.isString() || type.isStringLiteral())
+        return { type: "string" };
+    if (type.isNumber() || type.isNumberLiteral())
+        return { type: "integer" };
+    if (type.isBoolean() || type.isBooleanLiteral())
+        return { type: "boolean" };
+    if (type.isArray()) {
+        const arrayType = type.getArrayElementType();
+        return {
+            type: "array",
+            items: arrayType ? resolveSchema(arrayType, collectedSchemas) : {},
+        };
+    }
+    // 2. Handle Union Types (Enums)
+    if (type.isUnion()) {
+        const unionTypes = type.getUnionTypes();
+        // Extract literal values (e.g., "active", 100)
+        const literals = unionTypes
+            .map(t => t.isLiteral() ? t.getLiteralValue() : null)
+            .filter(val => val !== null);
+        // If we found literals, it's an Enum
+        if (literals.length > 0) {
+            const isString = typeof literals[0] === 'string';
+            return {
+                type: isString ? 'string' : 'integer',
+                enum: literals
+            };
+        }
+        // If it's a mix of objects (e.g. User | Admin), OpenApi uses 'oneOf'
+        // Simplified for this demo: take the first non-null type
+        return resolveSchema(unionTypes[0], collectedSchemas);
+    }
+    // 3. Handle Objects (Classes, Interfaces, Nested Literals)
+    if (type.isObject()) {
+        // Recursion Guard: If we've seen this type name before in components, reference it!
+        // (This prevents infinite loops and reduces swagger size)
+        const symbol = type.getSymbol();
+        const typeName = symbol?.getName();
+        // Common excluded types
+        if (typeName === "Promise") {
+            return resolveSchema(type.getTypeArguments()[0], collectedSchemas);
+        }
+        if (typeName === "Date")
+            return { type: "string", format: "date-time" };
+        // If it's a named class/interface (e.g. "Address"), and we haven't processed it, 
+        // we could add it to components.schemas. For now, we inline it for simplicity.
+        const properties = type.getProperties();
+        const schema = { type: "object", properties: {}, required: [] };
+        properties.forEach((prop) => {
+            const propName = prop.getName();
+            if (propName.startsWith("_"))
+                return; // Skip privates
+            // Get the type of the property using getTypeAtLocation
+            const declarations = prop.getDeclarations();
+            if (declarations.length > 0) {
+                const propType = prop.getTypeAtLocation(declarations[0]);
+                if (propType) {
+                    // RECURSION HERE: Pass the property type back into resolveSchema
+                    schema.properties[propName] = resolveSchema(propType, collectedSchemas);
+                    if (!prop.isOptional()) {
+                        schema.required.push(propName);
+                    }
+                }
+            }
+        });
+        return schema;
+    }
+    return { type: "string" }; // Fallback
+}
+function processController(classDec) {
+    const controllerDec = classDec.getDecorators().find((d) => d.getName() === "Controller");
+    if (!controllerDec)
+        return;
+    const basePath = controllerDec.getArguments()[0]?.getText().replace(/['"]/g, "") || "/";
+    classDec.getMethods().forEach((method) => {
+        const getDec = method.getDecorator("Get");
+        const postDec = method.getDecorator("Post");
+        const putDec = method.getDecorator("Put");
+        const deleteDec = method.getDecorator("Delete");
+        const decorator = getDec || postDec || putDec || deleteDec;
+        if (!decorator)
+            return;
+        const httpMethod = getDec ? "get" : postDec ? "post" : putDec ? "put" : "delete";
+        const pathArg = decorator.getArguments()[0]?.getText().replace(/['"]/g, "") || "/";
+        const fullPath = `/${basePath}${pathArg}`.replace("//", "/");
+        const parameters = [];
+        const requestBody = { content: {} };
+        // --- 1. Request Analysis (Input DTOs) ---
+        const params = method.getParameters();
+        if (params.length > 0) {
+            const param = params[0];
+            const paramType = param.getType(); // This resolves generics and inheritance!
+            // Iterate ALL properties of the type (inherited included)
+            paramType.getProperties().forEach(prop => {
+                const propName = prop.getName();
+                // We need to check Decorators. 
+                // Note: In mapped types/generics, getting decorators is hard.
+                // We fallback to checking the source declaration.
+                const declarations = prop.getDeclarations();
+                let isQuery = false;
+                let isBody = false;
+                let isPath = false;
+                // Check decorators on the definition
+                declarations.forEach(decl => {
+                    if (decl.getKind() === SyntaxKind.PropertyDeclaration) {
+                        const pDecl = decl;
+                        if (pDecl.getDecorator("FromQuery"))
+                            isQuery = true;
+                        if (pDecl.getDecorator("FromPath"))
+                            isPath = true;
+                        if (pDecl.getDecorator("FromBody"))
+                            isBody = true;
+                    }
+                });
+                // IMPLICIT RULES:
+                // If it's a GET, and not path, default to Query.
+                // If it's a POST, and not path/query, default to Body.
+                if (!isQuery && !isPath && !isBody) {
+                    if (httpMethod === "get")
+                        isQuery = true;
+                    else
+                        isBody = true;
+                }
+                const propType = prop.getTypeAtLocation(param.getSourceFile());
+                const propTypeSchema = resolveSchema(propType, openApiSpec.components.schemas);
+                if (isPath) {
+                    parameters.push({ name: propName, in: "path", required: true, schema: propTypeSchema });
+                }
+                else if (isQuery) {
+                    parameters.push({ name: propName, in: "query", required: !prop.isOptional(), schema: propTypeSchema });
+                }
+                else if (isBody) {
+                    if (!requestBody.content["application/json"]) {
+                        requestBody.content["application/json"] = { schema: { type: "object", properties: {}, required: [] } };
+                    }
+                    const bodySchema = requestBody.content["application/json"].schema;
+                    bodySchema.properties[propName] = propTypeSchema;
+                    if (!prop.isOptional())
+                        bodySchema.required.push(propName);
+                }
+            });
+        }
+        // --- 2. Authentication Check ---
+        const authDec = method.getDecorator("Authorized");
+        const controllerAuthDec = classDec.getDecorator("Authorized");
+        const isAuth = !!authDec || !!controllerAuthDec;
+        // --- 3. Response Analysis (Return Type) ---
+        const returnType = method.getReturnType(); // e.g. Promise<EntityResponse<User>>
+        const responseSchema = resolveSchema(returnType, openApiSpec.components.schemas);
+        if (!openApiSpec.paths[fullPath])
+            openApiSpec.paths[fullPath] = {};
+        openApiSpec.paths[fullPath][httpMethod] = {
+            operationId: method.getName(),
+            parameters,
+            requestBody: Object.keys(requestBody.content).length ? requestBody : undefined,
+            security: isAuth ? [{ bearerAuth: [] }] : undefined,
+            responses: {
+                200: {
+                    description: "Success",
+                    content: {
+                        "application/json": { schema: responseSchema }
+                    }
+                }
+            }
+        };
+    });
+}
+console.log("🔍 Scanning...");
+const sourceFiles = project.getSourceFiles("src/**/*.ts");
+sourceFiles.forEach(file => file.getClasses().forEach(processController));
+fs.writeFileSync(OUTPUT_FILE, JSON.stringify(openApiSpec, null, 2));
+console.log(`✅ Generated ${OUTPUT_FILE}`);

package/dist/controllers/advanced.controller.js

@@ -0,0 +1,131 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+// src/controllers/advanced.controller.ts
+import { Controller, Get, Post, FromBody, FromPath } from "../lib/decorators.js";
+import { PaginationQuery } from "../lib/common.js";
+// --- 1. Advanced Request DTOs ---
+// INHERITANCE: UserListRequest automatically gets 'page' and 'limit' from PaginationQuery
+// AND the generator will find them because we scan the Type properties.
+let UserListRequest = (() => {
+    let _classSuper = PaginationQuery;
+    let _tenantId_decorators;
+    let _tenantId_initializers = [];
+    let _tenantId_extraInitializers = [];
+    return class UserListRequest extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _tenantId_decorators = [FromPath()];
+            __esDecorate(null, null, _tenantId_decorators, { kind: "field", name: "tenantId", static: false, private: false, access: { has: obj => "tenantId" in obj, get: obj => obj.tenantId, set: (obj, value) => { obj.tenantId = value; } }, metadata: _metadata }, _tenantId_initializers, _tenantId_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        // Implicitly @FromQuery because it's a GET request and extends a class
+        search;
+        tenantId = __runInitializers(this, _tenantId_initializers, void 0);
+        constructor() {
+            super(...arguments);
+            __runInitializers(this, _tenantId_extraInitializers);
+        }
+    };
+})();
+export { UserListRequest };
+// COMPOSITION: Using the Type Helper for safety, but class for Decorators
+// We implement the Type Helper to ensure our Class matches the Entity rule
+let CreateUserDto = (() => {
+    let _name_decorators;
+    let _name_initializers = [];
+    let _name_extraInitializers = [];
+    let _email_decorators;
+    let _email_initializers = [];
+    let _email_extraInitializers = [];
+    return class CreateUserDto {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _name_decorators = [FromBody()];
+            _email_decorators = [FromBody()];
+            __esDecorate(null, null, _name_decorators, { kind: "field", name: "name", static: false, private: false, access: { has: obj => "name" in obj, get: obj => obj.name, set: (obj, value) => { obj.name = value; } }, metadata: _metadata }, _name_initializers, _name_extraInitializers);
+            __esDecorate(null, null, _email_decorators, { kind: "field", name: "email", static: false, private: false, access: { has: obj => "email" in obj, get: obj => obj.email, set: (obj, value) => { obj.email = value; } }, metadata: _metadata }, _email_initializers, _email_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        name = __runInitializers(this, _name_initializers, void 0);
+        email = (__runInitializers(this, _name_extraInitializers), __runInitializers(this, _email_initializers, void 0));
+        constructor() {
+            __runInitializers(this, _email_extraInitializers);
+        }
+    };
+})();
+export { CreateUserDto };
+// --- 2. The Controller ---
+let AdvancedController = (() => {
+    let _classDecorators = [Controller("advanced")];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _instanceExtraInitializers = [];
+    let _listUsers_decorators;
+    let _create_decorators;
+    var AdvancedController = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _listUsers_decorators = [Get("/{tenantId}/users")];
+            _create_decorators = [Post("/")];
+            __esDecorate(this, null, _listUsers_decorators, { kind: "method", name: "listUsers", static: false, private: false, access: { has: obj => "listUsers" in obj, get: obj => obj.listUsers }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _create_decorators, { kind: "method", name: "create", static: false, private: false, access: { has: obj => "create" in obj, get: obj => obj.create }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            AdvancedController = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        async listUsers(req) {
+            return [
+                { id: "1", name: "Alice", email: "a@a.com", isActive: true, createdAt: "now" }
+            ];
+        }
+        async create(req) {
+            return {
+                id: "123",
+                name: req.name,
+                email: req.email,
+                isActive: true,
+                createdAt: "now"
+            };
+        }
+        constructor() {
+            __runInitializers(this, _instanceExtraInitializers);
+        }
+    };
+    return AdvancedController = _classThis;
+})();
+export { AdvancedController };