adorn-api 1.0.0

package/dist/controllers/user.controller.js

@@ -0,0 +1,121 @@
+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/user.controller.ts
+import { Controller, Get, Post, FromQuery, FromPath, FromBody } from "../lib/decorators.js";
+// --- DTO Definitions (The substitute for Parameter Decorators) ---
+let GetUserRequest = (() => {
+    let _userId_decorators;
+    let _userId_initializers = [];
+    let _userId_extraInitializers = [];
+    let _details_decorators;
+    let _details_initializers = [];
+    let _details_extraInitializers = [];
+    return class GetUserRequest {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _userId_decorators = [FromPath()];
+            _details_decorators = [FromQuery()];
+            __esDecorate(null, null, _userId_decorators, { kind: "field", name: "userId", static: false, private: false, access: { has: obj => "userId" in obj, get: obj => obj.userId, set: (obj, value) => { obj.userId = value; } }, metadata: _metadata }, _userId_initializers, _userId_extraInitializers);
+            __esDecorate(null, null, _details_decorators, { kind: "field", name: "details", static: false, private: false, access: { has: obj => "details" in obj, get: obj => obj.details, set: (obj, value) => { obj.details = value; } }, metadata: _metadata }, _details_initializers, _details_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        userId = __runInitializers(this, _userId_initializers, void 0);
+        details = (__runInitializers(this, _userId_extraInitializers), __runInitializers(this, _details_initializers, void 0));
+        constructor() {
+            __runInitializers(this, _details_extraInitializers);
+        }
+    };
+})();
+export { GetUserRequest };
+let CreateUserRequest = (() => {
+    let _name_decorators;
+    let _name_initializers = [];
+    let _name_extraInitializers = [];
+    let _email_decorators;
+    let _email_initializers = [];
+    let _email_extraInitializers = [];
+    return class CreateUserRequest {
+        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 { CreateUserRequest };
+// --- The Controller ---
+let UserController = (() => {
+    let _classDecorators = [Controller("users")];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _instanceExtraInitializers = [];
+    let _getUser_decorators;
+    let _createUser_decorators;
+    var UserController = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _getUser_decorators = [Get("/{userId}")];
+            _createUser_decorators = [Post("/")];
+            __esDecorate(this, null, _getUser_decorators, { kind: "method", name: "getUser", static: false, private: false, access: { has: obj => "getUser" in obj, get: obj => obj.getUser }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _createUser_decorators, { kind: "method", name: "createUser", static: false, private: false, access: { has: obj => "createUser" in obj, get: obj => obj.createUser }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            UserController = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        // Strong typing: 'req' is checked at edit time.
+        async getUser(req) {
+            return `Getting user ${req.userId} with details: ${req.details}`;
+        }
+        async createUser(req) {
+            console.log(`Creating user ${req.name}`);
+        }
+        constructor() {
+            __runInitializers(this, _instanceExtraInitializers);
+        }
+    };
+    return UserController = _classThis;
+})();
+export { UserController };

package/dist/entities/user.entity.js

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,2 @@
+console.log("App loaded. Run 'npm run gen' to see swagger output.");
+export {};

package/dist/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/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/middleware/auth.middleware.js

@@ -0,0 +1,13 @@
+export function authenticationMiddleware(req, res, next) {
+    const token = req.headers.authorization;
+    if (!token) {
+        res.status(401).json({ message: "No token provided" });
+        return;
+    }
+    if (token === "Bearer secret") {
+        next();
+    }
+    else {
+        res.status(403).json({ message: "Invalid token" });
+    }
+}

package/dist/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/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/src/cli/generate-routes.js

@@ -0,0 +1,105 @@
+// src/cli/generate-routes.ts
+import path from "path";
+import { Project } from "ts-morph";
+import * as fs from "fs";
+const PROJECT_ROOT = "./tsconfig.json";
+const OUTPUT_FILE = "./tests/example-app/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 exampleAppRoot = path.join(process.cwd(), "tests", "example-app");
+    const relativeDir = path.relative(exampleAppRoot, sourceFile.getDirectoryPath());
+    const relativeSegments = relativeDir ? relativeDir.split(path.sep) : [];
+    const baseName = sourceFile.getBaseName().replace(/\.ts$/, ".js");
+    const importPath = `./${path.posix.join(...relativeSegments, baseName)}`;
+    imports.add(`import { ${className} } from '${importPath}';`);
+    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("tests/example-app/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}`);