xtaskjs 1.0.0

package/dist/packages/core/src/di/qualifier.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Qualifier = Qualifier;
+exports.getQualifier = getQualifier;
+exports.getConstructorQualifiers = getConstructorQualifiers;
+require("reflect-metadata");
+const QUALIFIER_KEY = Symbol("xtaskjs:qualifier");
+function Qualifier(name) {
+    return function (target, propertyKey, parameterIndex) {
+        if (parameterIndex !== undefined) {
+            // Parameter decorator
+            const existingQualifiers = Reflect.getMetadata(QUALIFIER_KEY, target) || {};
+            existingQualifiers[parameterIndex] = name;
+            Reflect.defineMetadata(QUALIFIER_KEY, existingQualifiers, target);
+        }
+    };
+}
+function getQualifier(target, propertyKey) {
+    if (propertyKey) {
+        return Reflect.getMetadata(QUALIFIER_KEY, target, propertyKey);
+    }
+    return undefined;
+}
+function getConstructorQualifiers(target) {
+    return Reflect.getMetadata(QUALIFIER_KEY, target);
+}

package/dist/packages/core/src/di/stereotypes.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Repository = exports.Controller = exports.Service = void 0;
+const component_1 = require("./component");
+const Service = (options = {}) => (0, component_1.Component)({ ...options, type: "service" });
+exports.Service = Service;
+const Controller = (options = {}) => (0, component_1.Component)({ ...options, type: "controller" });
+exports.Controller = Controller;
+const Repository = (options = {}) => (0, component_1.Component)({ ...options, type: "repository" });
+exports.Repository = Repository;

package/dist/packages/core/src/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+__exportStar(require("./bootstrap"), exports);
+__exportStar(require("./kernel"), exports);
+__exportStar(require("./di"), exports);
+__exportStar(require("./server"), exports);

package/dist/packages/core/src/kernel/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./kernel"), exports);
+__exportStar(require("./kernellisteners"), exports);

package/dist/packages/core/src/kernel/kernel.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Kernel = void 0;
+require("reflect-metadata");
+const core_1 = require("@xtaskjs/core");
+const common_1 = require("@xtaskjs/common");
+class Kernel {
+    container;
+    logger;
+    constructor() {
+    }
+    async boot() {
+        // Bootstrapping logic here
+        this.container = new core_1.Container();
+        // Autoload components from the "packages" directory
+        await this.container.autoload("packages");
+        this.logger = await this.container.get(common_1.Logger);
+        // Simulate some async operation
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        this.logger.info("🚀 Kernel started successfully.");
+    }
+    async getContainer() {
+        return this.container;
+    }
+}
+exports.Kernel = Kernel;

package/dist/packages/core/src/kernel/kernellisteners.js

@@ -0,0 +1,72 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KernelListeners = void 0;
+require("reflect-metadata");
+const common_1 = require("@xtaskjs/common");
+// Clase que escucha eventos del ciclo de vida
+class KernelListeners {
+    onStarting() {
+        console.log("[Lifecycle] Starting...");
+    }
+    onReady() {
+        console.log("[Lifecycle] Application ready!");
+    }
+    async afterStart() {
+        console.log("[Runner] ApplicationRunner ejecutado después de arrancar Kernel");
+    }
+    async cli(args) {
+        console.log("[Runner] CommandLineRunner con args:", args);
+    }
+    memory(mem) {
+        console.log("[Metrics] Heap MB:", (mem.heapUsed / 1024 / 1024).toFixed(2));
+    }
+    cpu(calc) {
+        console.log("CPU", (calc));
+    }
+}
+exports.KernelListeners = KernelListeners;
+__decorate([
+    (0, common_1.OnEvent)("starting"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], KernelListeners.prototype, "onStarting", null);
+__decorate([
+    (0, common_1.OnEvent)("ready"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], KernelListeners.prototype, "onReady", null);
+__decorate([
+    (0, common_1.ApplicationRunner)(5),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], KernelListeners.prototype, "afterStart", null);
+__decorate([
+    (0, common_1.CommandLineRunner)(0),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", Promise)
+], KernelListeners.prototype, "cli", null);
+__decorate([
+    (0, common_1.OnEvent)("memoryReport"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], KernelListeners.prototype, "memory", null);
+__decorate([
+    (0, common_1.OnEvent)("cpuReport"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], KernelListeners.prototype, "cpu", null);

package/dist/packages/core/src/server/application-lifecycle.js

@@ -0,0 +1,103 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplicationLifeCycle = void 0;
+const os = __importStar(require("os"));
+const process = __importStar(require("process"));
+class ApplicationLifeCycle {
+    listeners = new Map();
+    metricsInterval;
+    runners = [];
+    constructor() { }
+    on(event, Listener, priority = 0) {
+        const list = this.listeners.get(event) || [];
+        list.push({ fn: Listener, priority });
+        this.listeners.set(event, list.sort((a, b) => b.priority - a.priority));
+    }
+    registerRunner(fn, type = "ApplicationRunner", priority = 0) {
+        this.runners.push({ fn, type, priority });
+        this.runners.sort((a, b) => b.priority - a.priority);
+    }
+    async emit(event, payload) {
+        const list = this.listeners.get(event) || [];
+        for (const { fn, priority } of list) {
+            try {
+                await Promise.resolve(fn(payload));
+            }
+            catch (error) {
+                console.error(`Error in lifecycle handler for phase ${event} (priority ${priority}):`, error);
+                if (event != "error") {
+                    await this.emit("error", error);
+                }
+            }
+        }
+    }
+    async runRunners(type) {
+        for (const runner of this.runners.filter(r => r.type === type)) {
+            await Promise.resolve(runner.fn(process.argv.slice(2)));
+        }
+    }
+    async boot(startFn) {
+        try {
+            await this.emit("starting");
+            await this.emit("environmentPrepared", { env: process.env, args: process.argv });
+            await this.emit("contextPrepared");
+            await this.emit("serverStarting");
+            await startFn();
+            await this.emit("serverStarted");
+            this.metricsInterval = setInterval(async () => {
+                await this.emit("memoryReport", process.memoryUsage());
+                await this.emit("cpuReport", {
+                    loadavg: os.loadavg(),
+                    usage: process.cpuUsage()
+                });
+            }, 5000); //every minute
+            await this.runRunners("ApplicationRunner");
+            await this.emit("ready");
+            await this.runRunners("CommandLineRunner");
+        }
+        catch (error) {
+            await this.emit("error", error);
+            throw error;
+        }
+    }
+    async stop() {
+        if (this.metricsInterval) {
+            clearInterval(this.metricsInterval);
+            this.metricsInterval = undefined;
+        }
+    }
+}
+exports.ApplicationLifeCycle = ApplicationLifeCycle;

package/dist/packages/core/src/server/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./application-lifecycle"), exports);
+__exportStar(require("./registereventhandlers"), exports);
+__exportStar(require("../../../common/src/types/runnermeta"), exports);

package/dist/packages/core/src/server/registereventhandlers.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerEventHandlers = registerEventHandlers;
+require("reflect-metadata");
+const common_1 = require("@xtaskjs/common");
+function registerEventHandlers(instance, app) {
+    const handlers = Reflect.getMetadata(common_1.HANDLERS_KEY, instance.constructor) || [];
+    for (const { phase, method, priority } of handlers.sort((a, b) => b.priority - a.priority)) {
+        app.on(phase, async (...args) => instance[method](...args), priority);
+    }
+    const runners = Reflect.getMetadata(common_1.RUNNERS_KEY, instance.constructor) || [];
+    for (const { type, method, priority } of runners.sort((a, b) => b.priority - a.priority)) {
+        app.registerRunner((args) => instance[method](...args), type, priority);
+    }
+}

package/dist/packages/core/test/di/autowired.test.js

@@ -0,0 +1,92 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../../src/di/index");
+let Logger = class Logger {
+    log(message) {
+        return `Log: ${message}`;
+    }
+};
+Logger = __decorate([
+    (0, index_1.Service)()
+], Logger);
+let Database = class Database {
+    query(sql) {
+        return `Result of "${sql}"`;
+    }
+};
+Database = __decorate([
+    (0, index_1.Service)()
+], Database);
+let UserService = class UserService {
+    logger;
+    database;
+    getUser(id) {
+        this.logger.log(`Fetching user with id: ${id}`);
+        return this.database.query(`SELECT * FROM users WHERE id = ${id}`);
+    }
+};
+__decorate([
+    (0, index_1.AutoWired)(),
+    __metadata("design:type", Logger)
+], UserService.prototype, "logger", void 0);
+__decorate([
+    (0, index_1.AutoWired)(),
+    __metadata("design:type", Database)
+], UserService.prototype, "database", void 0);
+UserService = __decorate([
+    (0, index_1.Service)()
+], UserService);
+let OptionalDependencyService = class OptionalDependencyService {
+    optionalLogger;
+    hasLogger() {
+        return this.optionalLogger !== undefined;
+    }
+};
+__decorate([
+    (0, index_1.AutoWired)({ required: false }),
+    __metadata("design:type", Logger)
+], OptionalDependencyService.prototype, "optionalLogger", void 0);
+OptionalDependencyService = __decorate([
+    (0, index_1.Service)()
+], OptionalDependencyService);
+describe("AutoWired Decorator", () => {
+    let container;
+    beforeEach(() => {
+        container = new index_1.Container();
+    });
+    it("should inject dependencies into UserService", () => {
+        container.register(Logger, { scope: "singleton" });
+        container.register(Database, { scope: "singleton" });
+        container.register(UserService, { scope: "singleton" });
+        const userService = container.get(UserService);
+        expect(userService).toBeInstanceOf(UserService);
+        //  expect(userService.getUser(1)).toBe('Result of "SELECT * FROM users WHERE id = 1"');
+    });
+    it("should handle optional dependencies", () => {
+        container.register(OptionalDependencyService, { scope: "singleton" });
+        const optionalService = container.get(OptionalDependencyService);
+        expect(optionalService).toBeInstanceOf(OptionalDependencyService);
+        expect(optionalService.hasLogger()).toBe(false); // Logger is not registered, should be undefined
+    });
+    it("should throw error for missing required dependencies", () => {
+        container.register(UserService, { scope: "singleton" });
+        expect(() => container.get(UserService)).toThrow();
+    });
+    it("should inject dependencies into constructor and field dependencies", () => {
+        container.register(Logger, { scope: "singleton" });
+        container.register(Database, { scope: "singleton" });
+        container.register(UserService, { scope: "singleton" });
+        const userService = container.get(UserService);
+        expect(userService).toBeDefined();
+        expect(userService.getUser(1)).toBeDefined();
+    });
+});

package/dist/packages/core/test/di/container.test.js

@@ -0,0 +1,43 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../../src/di/index");
+let TestService = class TestService {
+    getValue() {
+        return 42;
+    }
+};
+TestService = __decorate([
+    (0, index_1.Service)()
+], TestService);
+describe("Container", () => {
+    let container;
+    beforeEach(() => {
+        container = new index_1.Container();
+    });
+    it("should register and resolve a singleton service", () => {
+        container.register(TestService, { scope: "singleton" });
+        const resolved = container.get(TestService);
+        expect(resolved.getValue()).toBe(42);
+    });
+    it("should return singleton instances y default ", () => {
+        container.register(TestService, { scope: "singleton" });
+        const instance1 = container.get(TestService);
+        const instance2 = container.get(TestService);
+        expect(instance1).toBe(instance2); // Same instance
+    });
+    it("should return new instances for transient scope", () => {
+        container.register(TestService, { scope: "transient" });
+        const instance1 = container.get(TestService);
+        const instance2 = container.get(TestService);
+        expect(instance1).not.toBe(instance2); // Different instances
+    });
+    it("should throw error for unregistered services", () => {
+        expect(() => container.get(TestService)).toThrow("No provider found for TestService");
+    });
+});

package/dist/packages/core/test/di/qualifier.test.js

@@ -0,0 +1,71 @@
+"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); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../../src/di/index");
+let EmailNotificationService = class EmailNotificationService {
+    send(message) {
+        return `Email sent: ${message}`;
+    }
+};
+EmailNotificationService = __decorate([
+    (0, index_1.Service)({ name: "emailNotificer" })
+], EmailNotificationService);
+let SMSNotificationService = class SMSNotificationService {
+    send(message) {
+        return `SMS sent: ${message}`;
+    }
+};
+SMSNotificationService = __decorate([
+    (0, index_1.Service)({ name: "smsNotificer" })
+], SMSNotificationService);
+let OrderService = class OrderService {
+    emailService;
+    smsService;
+    constructor(emailService, smsService) {
+        this.emailService = emailService;
+        this.smsService = smsService;
+    }
+};
+OrderService = __decorate([
+    (0, index_1.Service)(),
+    __param(0, (0, index_1.Qualifier)("emailNotificer")),
+    __param(1, (0, index_1.Qualifier)("smsNotificer")),
+    __metadata("design:paramtypes", [Object, Object])
+], OrderService);
+describe("Qualifier Decorator", () => {
+    let container;
+    beforeEach(() => {
+        container = new index_1.Container();
+    });
+    it("should inject beans by qualifier name", () => {
+        container.registerWithName(EmailNotificationService, { scope: "singleton" }, "emailNotificer");
+        container.registerWithName(SMSNotificationService, { scope: "singleton" }, "smsNotificer");
+        container.register(OrderService, { scope: "singleton" });
+        const orderService = container.get(OrderService);
+        expect(orderService).toBeInstanceOf(OrderService);
+        expect(orderService['emailService']).toBeInstanceOf(EmailNotificationService);
+        expect(orderService['smsService']).toBeInstanceOf(SMSNotificationService);
+        expect(orderService.emailService.send("Hello")).toBe("Email sent: Hello");
+        expect(orderService.smsService.send("Hello")).toBe("SMS sent: Hello");
+    });
+    it("should retrieve beans by name from container", () => {
+        container.registerWithName(EmailNotificationService, { scope: "singleton" }, "emailNotificer");
+        const notifier = container.getByName("emailNotificer");
+        expect(notifier).toBeInstanceOf(EmailNotificationService);
+        expect(notifier.send("Test")).toBe("Email sent: Test");
+    });
+    it("should throw error for unknown qualifier names", () => {
+        expect(() => container.getByName("unknownService")).toThrow("No component found with name: unknownService");
+    });
+});

package/dist/packages/core/test/logger/logger.test.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = require("@xtaskjs/common");
+describe("Logger", () => {
+    it("Should print logs", () => {
+        const logger = new common_1.Logger();
+        const spy = jest.spyOn(console, "log").mockImplementation();
+        logger.info("hello");
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining("hello"));
+        spy.mockRestore();
+    });
+});

package/dist/packages/core/test/server/applicationlifecycle.test.js

@@ -0,0 +1,28 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = require("@xtaskjs/common");
+const src_1 = require("packages/core/src");
+let TestLifeCycleListener = class TestLifeCycleListener {
+    events = [];
+    async onStarting() {
+        this.events.push("starting");
+    }
+};
+__decorate([
+    (0, common_1.OnEvent)('starting', 10),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], TestLifeCycleListener.prototype, "onStarting", null);
+TestLifeCycleListener = __decorate([
+    (0, src_1.Service)()
+], TestLifeCycleListener);

package/jest.config.js

@@ -0,0 +1,9 @@
+module.exports = {
+    transformIgnorePatterns: ['node_modules/(?!(sucrase)/)'],
+    transform: {
+        '^.+\\.(js|jsx|ts|tsx|mjs)$': 'babel-jest',
+    },
+    preset: 'ts-jest',
+    testEnvironment: 'node',
+    cacheDirectory: '.tmp/jestCache'
+};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "xtaskjs",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "workspaces": [
+    "packages/*"
+  ],
+  "scripts": {
+    "start": "ts-node -r tsconfig-paths/register app.ts",
+    "build": "npm run clean; tsc",
+    "test": "npm run test --prefix packages/core && npm run test --prefix packages/common",
+    "clean": "rm -r dist"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "express": "^5.1.0",
+    "reflect-metadata": "^0.2.2",
+    "ts-morph": "^27.0.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.28.4",
+    "@babel/preset-env": "^7.28.3",
+    "@jest/globals": "^30.1.2",
+    "@types/express": "^5.0.3",
+    "@types/jest": "^30.0.0",
+    "babel-jest": "^30.1.2",
+    "jest": "^30.1.3",
+    "nodemon": "^3.1.10",
+    "ts-jest": "^29.4.4",
+    "ts-node": "^10.9.2",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.9.2"
+  }
+}

package/packages/common/README.md

@@ -0,0 +1,21 @@
+# @xtaskjs/common
+
+Common utilities for xtaskjs, a modern, fast Node.js web framework.
+
+## Installation
+```bash
+npm install @xtaskjs/common
+```
+
+## Usage
+```typescript
+import { ... } from '@xtaskjs/common';
+```
+
+## Features
+- Logger
+- Decorators
+- Shared types and constants
+
+## Documentation
+See [xtaskjs.com](https://xtaskjs.com) for full documentation.

package/packages/common/babel.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+  presets: ['next/babel'],
+}

package/packages/common/index.ts

@@ -0,0 +1 @@
+export * from "./src";

package/packages/common/jest.config.js

@@ -0,0 +1,11 @@
+const { createDefaultPreset } = require("ts-jest");
+
+const tsJestTransformCfg = createDefaultPreset().transform;
+
+/** @type {import("jest").Config} **/
+module.exports = {
+  testEnvironment: "node",
+  transform: {
+    ...tsJestTransformCfg,
+  },
+};