@zenofolio/hyper-decor 1.0.63 → 1.0.64

package/dist/run-bench.d.ts

@@ -0,0 +1 @@
+import "reflect-metadata";

package/dist/run-bench.js

@@ -0,0 +1,190 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const src_1 = require("./src");
+const tsyringe_1 = require("tsyringe");
+const request_1 = require("./tests/helpers/request");
+// Global counter to verify execution
+let initCounter = 0;
+const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+let StaticServiceA = class StaticServiceA {
+    onInit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield delay(5);
+            initCounter++;
+        });
+    }
+    getValue() { return "A"; }
+};
+StaticServiceA = __decorate([
+    (0, tsyringe_1.injectable)(),
+    (0, src_1.HyperService)()
+], StaticServiceA);
+let StaticServiceB = class StaticServiceB {
+    onInit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield delay(5);
+            initCounter++;
+        });
+    }
+    getValue() { return "B"; }
+};
+StaticServiceB = __decorate([
+    (0, tsyringe_1.injectable)(),
+    (0, src_1.HyperService)()
+], StaticServiceB);
+let BenchController = class BenchController {
+    verify(res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            res.json({
+                count: initCounter,
+                status: "ok"
+            });
+        });
+    }
+};
+__decorate([
+    (0, src_1.Get)("/"),
+    __param(0, (0, src_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [src_1.Response]),
+    __metadata("design:returntype", Promise)
+], BenchController.prototype, "verify", null);
+BenchController = __decorate([
+    (0, src_1.HyperController)("/verify")
+], BenchController);
+let BenchModule = class BenchModule {
+};
+BenchModule = __decorate([
+    (0, src_1.HyperModule)({
+        imports: [StaticServiceA, StaticServiceB],
+        controllers: [BenchController]
+    })
+], BenchModule);
+let App = class App {
+};
+App = __decorate([
+    (0, src_1.HyperApp)({
+        modules: [BenchModule]
+    })
+], App);
+let CircularA = class CircularA {
+    constructor(b) {
+        this.b = b;
+    }
+    onInit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield delay(10);
+            initCounter++;
+        });
+    }
+    getName() { return "A"; }
+};
+CircularA = __decorate([
+    (0, tsyringe_1.injectable)(),
+    (0, src_1.HyperService)(),
+    __param(0, (0, tsyringe_1.inject)((0, tsyringe_1.delay)(() => CircularB))),
+    __metadata("design:paramtypes", [Object])
+], CircularA);
+let CircularB = class CircularB {
+    constructor(a) {
+        this.a = a;
+    }
+    onInit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield delay(10);
+            initCounter++;
+        });
+    }
+    getName() { return "B"; }
+};
+CircularB = __decorate([
+    (0, tsyringe_1.injectable)(),
+    (0, src_1.HyperService)(),
+    __param(0, (0, tsyringe_1.inject)((0, tsyringe_1.delay)(() => CircularA))),
+    __metadata("design:paramtypes", [Object])
+], CircularB);
+let CircularModule = class CircularModule {
+};
+CircularModule = __decorate([
+    (0, src_1.HyperModule)({
+        imports: [CircularA, CircularB]
+    })
+], CircularModule);
+let CircularApp = class CircularApp {
+};
+CircularApp = __decorate([
+    (0, src_1.HyperApp)({
+        modules: [CircularModule]
+    })
+], CircularApp);
+function runBenchmarks() {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log("Enhanced Performance & Robustness Benchmark");
+        // Test 1
+        console.log("\n-> should verify service execution and fetch liveliness");
+        initCounter = 0;
+        tsyringe_1.container.reset();
+        const start = Date.now();
+        const app = yield (0, src_1.createApplication)(App);
+        const duration = Date.now() - start;
+        yield app.listen(3005);
+        const responseText = yield (0, request_1.request)("/verify", undefined, 3005);
+        const response = JSON.parse(responseText);
+        console.log(`\n✅ LIVELINESS & EXECUTION:`);
+        console.log(`- Startup: ${duration}ms`);
+        console.log(`- Services Initialized: ${response.count}`);
+        console.log(`- Response: ${responseText}`);
+        if (response.status !== "ok")
+            throw new Error("Status not ok");
+        if (response.count !== 2)
+            throw new Error("Count not 2");
+        yield app.close();
+        // Test 2
+        console.log("\n-> should handle circular dependencies with delays");
+        tsyringe_1.container.reset();
+        initCounter = 0;
+        const app2 = yield (0, src_1.createApplication)(CircularApp);
+        const a = tsyringe_1.container.resolve(CircularA);
+        const b = tsyringe_1.container.resolve(CircularB);
+        console.log(`\n🔄 CIRCULAR DEP RESULTS:`);
+        console.log(`- CircularA sees name: ${a.b.getName()}`);
+        console.log(`- CircularB sees name: ${b.a.getName()}`);
+        console.log(`- Init Counter: ${initCounter}`);
+        if (a.b.getName() !== "B")
+            throw new Error("Mismatch B");
+        if (b.a.getName() !== "A")
+            throw new Error("Mismatch A");
+        if (initCounter !== 2)
+            throw new Error("Mismatch initCounter");
+        yield app2.close();
+    });
+}
+runBenchmarks().then(() => {
+    console.log("\nAll benchmarks finished successfully!");
+    process.exit(0);
+}).catch(e => {
+    console.error(e);
+    process.exit(1);
+});

package/dist/scripts/test-server.d.ts

@@ -0,0 +1 @@
+import "reflect-metadata";

package/dist/scripts/test-server.js

@@ -0,0 +1,110 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const src_1 = require("../src");
+const tsyringe_1 = require("tsyringe");
+// 1. Setup a Mock Transformer (Zod-like)
+const ZodTransformer = {
+    transform: ({ data, schema }) => {
+        if (schema._type === "zod") {
+            return Object.assign(Object.assign({}, data), { parsed: true, timestamp: Date.now() });
+        }
+        return data;
+    },
+};
+const mockSchema = { _type: "zod" };
+let AnalyticsService = class AnalyticsService {
+    onInit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log("Service initialized");
+        });
+    }
+};
+AnalyticsService = __decorate([
+    (0, tsyringe_1.injectable)(),
+    (0, src_1.HyperService)()
+], AnalyticsService);
+let MainController = class MainController {
+    status(res) {
+        res.json({ status: "alive" });
+    }
+    createUser(data) {
+        return data;
+    }
+};
+__decorate([
+    (0, src_1.Get)("/status"),
+    __param(0, (0, src_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [src_1.Response]),
+    __metadata("design:returntype", void 0)
+], MainController.prototype, "status", null);
+__decorate([
+    (0, src_1.Post)("/user"),
+    (0, src_1.Transform)(mockSchema),
+    __param(0, (0, src_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], MainController.prototype, "createUser", null);
+MainController = __decorate([
+    (0, src_1.HyperController)("/api")
+], MainController);
+let MainModule = class MainModule {
+};
+MainModule = __decorate([
+    (0, src_1.HyperModule)({
+        imports: [AnalyticsService],
+        controllers: [MainController]
+    })
+], MainModule);
+let FullApp = class FullApp {
+};
+FullApp = __decorate([
+    (0, src_1.HyperApp)({
+        name: "Standalone Test App",
+        version: "1.0.0",
+        modules: [MainModule]
+    })
+], FullApp);
+function run() {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log("Starting App...");
+        const app = yield (0, src_1.createApplication)(FullApp);
+        app.useTransform(ZodTransformer);
+        const port = 3010;
+        yield app.listen(port);
+        console.log(`Server listening on http://localhost:${port}`);
+        // Close after 5 seconds
+        setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+            console.log("Closing server...");
+            yield app.close();
+            process.exit(0);
+        }), 5000);
+    });
+}
+run().catch(err => {
+    console.error(err);
+    process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zenofolio/hyper-decor",
-  "version": "1.0.63",
+  "version": "1.0.64",
   "description": "Project core with utilities and features",
   "main": "dist/index.js",
   "author": "zenozaga",

package/scripts/test-server.ts

@@ -0,0 +1,85 @@
+import "reflect-metadata";
+import {
+  HyperApp,
+  HyperModule,
+  HyperService,
+  HyperController,
+  Get,
+  Post,
+  Res,
+  Body,
+  Response,
+  OnInit,
+  createApplication,
+  Transform,
+} from "../src";
+import { injectable } from "tsyringe";
+
+// 1. Setup a Mock Transformer (Zod-like)
+const ZodTransformer = {
+  transform: ({ data, schema }: any) => {
+    if (schema._type === "zod") {
+      return { ...data, parsed: true, timestamp: Date.now() };
+    }
+    return data;
+  },
+};
+
+const mockSchema = { _type: "zod" };
+
+@injectable()
+@HyperService()
+class AnalyticsService implements OnInit {
+  async onInit() {
+    console.log("Service initialized");
+  }
+}
+
+@HyperController("/api")
+class MainController {
+  @Get("/status")
+  status(@Res() res: Response) {
+    res.json({ status: "alive" });
+  }
+
+  @Post("/user")
+  @Transform(mockSchema)
+  createUser(@Body() data: any) {
+    return data;
+  }
+}
+
+@HyperModule({
+  imports: [AnalyticsService],
+  controllers: [MainController]
+})
+class MainModule { }
+
+@HyperApp({
+  name: "Standalone Test App",
+  version: "1.0.0",
+  modules: [MainModule]
+})
+class FullApp { }
+
+async function run() {
+  console.log("Starting App...");
+  const app = await createApplication(FullApp);
+  app.useTransform(ZodTransformer);
+
+  const port = 3010;
+  await app.listen(port);
+  console.log(`Server listening on http://localhost:${port}`);
+
+  // Close after 5 seconds
+  setTimeout(async () => {
+    console.log("Closing server...");
+    await app.close();
+    process.exit(0);
+  }, 5000);
+}
+
+run().catch(err => {
+  console.error(err);
+  process.exit(1);
+});