adorn-api 1.0.0

package/dist/src/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("tests/example-app/**/*.ts");
+sourceFiles.forEach(file => file.getClasses().forEach(processController));
+fs.writeFileSync(OUTPUT_FILE, JSON.stringify(openApiSpec, null, 2));
+console.log(`✅ Generated ${OUTPUT_FILE}`);

package/dist/src/index.js

@@ -0,0 +1,4 @@
+// src/index.ts
+// Main entry point for adorn-api library
+export * from "./lib/decorators.js";
+export * from "./lib/common.js";

package/dist/src/lib/common.js

@@ -0,0 +1,62 @@
+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/lib/common.ts
+import { FromQuery } from "./decorators.js";
+// --- 2. Pagination Logic ---
+// We need a Concrete Class for Pagination because it carries Metadata (@FromQuery)
+let PaginationQuery = (() => {
+    let _page_decorators;
+    let _page_initializers = [];
+    let _page_extraInitializers = [];
+    let _limit_decorators;
+    let _limit_initializers = [];
+    let _limit_extraInitializers = [];
+    return class PaginationQuery {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _page_decorators = [FromQuery()];
+            _limit_decorators = [FromQuery()];
+            __esDecorate(null, null, _page_decorators, { kind: "field", name: "page", static: false, private: false, access: { has: obj => "page" in obj, get: obj => obj.page, set: (obj, value) => { obj.page = value; } }, metadata: _metadata }, _page_initializers, _page_extraInitializers);
+            __esDecorate(null, null, _limit_decorators, { kind: "field", name: "limit", static: false, private: false, access: { has: obj => "limit" in obj, get: obj => obj.limit, set: (obj, value) => { obj.limit = value; } }, metadata: _metadata }, _limit_initializers, _limit_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        page = __runInitializers(this, _page_initializers, 1);
+        limit = (__runInitializers(this, _page_extraInitializers), __runInitializers(this, _limit_initializers, 20));
+        constructor() {
+            __runInitializers(this, _limit_extraInitializers);
+        }
+    };
+})();
+export { PaginationQuery };

package/dist/src/lib/decorators.js

@@ -0,0 +1,116 @@
+// src/lib/decorators.ts
+// Context metadata symbol for standard decorators
+const META_KEY = Symbol('adorn:route');
+export const SCHEMA_META = Symbol('adorn:schema');
+export const AUTH_META = Symbol('adorn:auth');
+// -- Method Decorator --
+// Using Standard TC39 Signature
+export function Get(path) {
+    return function (originalMethod, context) {
+        // In standard decorators, we can attach metadata to the class prototype via context
+        context.addInitializer(function () {
+            const routes = this[META_KEY] || [];
+            routes.push({
+                method: 'get',
+                path,
+                methodName: String(context.name),
+            });
+            this[META_KEY] = routes;
+        });
+        return originalMethod;
+    };
+}
+export function Post(path) {
+    return function (originalMethod, context) {
+        context.addInitializer(function () {
+            const routes = this[META_KEY] || [];
+            routes.push({
+                method: 'post',
+                path,
+                methodName: String(context.name),
+            });
+            this[META_KEY] = routes;
+        });
+        return originalMethod;
+    };
+}
+export function Put(path) {
+    return function (originalMethod, context) {
+        context.addInitializer(function () {
+            const routes = this[META_KEY] || [];
+            routes.push({
+                method: 'put',
+                path,
+                methodName: String(context.name),
+            });
+            this[META_KEY] = routes;
+        });
+        return originalMethod;
+    };
+}
+export function Delete(path) {
+    return function (originalMethod, context) {
+        context.addInitializer(function () {
+            const routes = this[META_KEY] || [];
+            routes.push({
+                method: 'delete',
+                path,
+                methodName: String(context.name),
+            });
+            this[META_KEY] = routes;
+        });
+        return originalMethod;
+    };
+}
+// -- Class Decorator --
+export function Controller(basePath) {
+    return function (target, context) {
+        // We attach the base path to the class constructor
+        context.addInitializer(function () {
+            this._basePath = basePath;
+        });
+        return target;
+    };
+}
+// -- DTO Field Decorators --
+// Since we can't decorate parameters, we decorate fields in a class
+// e.g. class GetUserParams { @FromPath id: string }
+export function FromQuery(name) {
+    return function (target, context) {
+        context.addInitializer(function () {
+            const meta = this[SCHEMA_META] || {};
+            meta[context.name] = { type: 'query' };
+            this[SCHEMA_META] = meta;
+        });
+        return function (initialValue) { return initialValue; };
+    };
+}
+export function FromPath(name) {
+    return function (target, context) {
+        context.addInitializer(function () {
+            const meta = this[SCHEMA_META] || {};
+            meta[context.name] = { type: 'path' };
+            this[SCHEMA_META] = meta;
+        });
+        return function (initialValue) { return initialValue; };
+    };
+}
+export function FromBody() {
+    return function (target, context) {
+        context.addInitializer(function () {
+            const meta = this[SCHEMA_META] || {};
+            meta[context.name] = { type: 'body' };
+            this[SCHEMA_META] = meta;
+        });
+        return function (initialValue) { return initialValue; };
+    };
+}
+// -- Authentication Decorator --
+export function Authorized(role) {
+    return function (target, context) {
+        context.addInitializer(function () {
+            this[AUTH_META] = role || 'default';
+        });
+        return target;
+    };
+}

package/dist/src/routes.js

@@ -0,0 +1,80 @@
+import { AdvancedController } from 'C:/Users/celso/Documents/projetos/adorn-api/src/controllers/advanced.controller.js';
+import { UserController } from 'C:/Users/celso/Documents/projetos/adorn-api/src/controllers/user.controller.js';
+export function RegisterRoutes(app) {
+    app.get('/advanced/:tenantId/users', async (req, res) => {
+        const controller = new AdvancedController();
+        try {
+            const input = {};
+            // 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'
+            const response = await controller.listUsers(input);
+            res.status(200).json(response);
+        }
+        catch (err) {
+            console.error(err);
+            res.status(500).send(err.message);
+        }
+    });
+    app.post('/advanced/', async (req, res) => {
+        const controller = new AdvancedController();
+        try {
+            const input = {};
+            // 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'
+            const response = await controller.create(input);
+            res.status(200).json(response);
+        }
+        catch (err) {
+            console.error(err);
+            res.status(500).send(err.message);
+        }
+    });
+    app.get('/users/:userId', async (req, res) => {
+        const controller = new UserController();
+        try {
+            const input = {};
+            // 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'
+            const response = await controller.getUser(input);
+            res.status(200).json(response);
+        }
+        catch (err) {
+            console.error(err);
+            res.status(500).send(err.message);
+        }
+    });
+    app.post('/users/', async (req, res) => {
+        const controller = new UserController();
+        try {
+            const input = {};
+            // 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'
+            const response = await controller.createUser(input);
+            res.status(200).json(response);
+        }
+        catch (err) {
+            console.error(err);
+            res.status(500).send(err.message);
+        }
+    });
+}

package/dist/src/server.js

@@ -0,0 +1,18 @@
+// src/server.ts
+import express from "express";
+import bodyParser from "body-parser";
+// This is the file we just generated!
+import { RegisterRoutes } from "./routes.js";
+import swaggerUi from "swagger-ui-express";
+import { readFileSync } from "fs";
+const app = express();
+app.use(bodyParser.json());
+// 1. Register the Generated Routes
+RegisterRoutes(app);
+// 2. Serve Swagger UI
+const swaggerDoc = JSON.parse(readFileSync("./swagger.json", "utf-8"));
+app.use("/docs", swaggerUi.serve, swaggerUi.setup(swaggerDoc));
+app.listen(3000, () => {
+    console.log("🚀 Server running on http://localhost:3000");
+    console.log("📄 Swagger running on http://localhost:3000/docs");
+});

package/dist/tests/example-app/controllers/advanced.controller.js

@@ -0,0 +1,130 @@
+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, PaginationQuery } from "../../../src/index.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 };