xtaskjs 1.0.0

package/packages/core/src/di/qualifier.ts

@@ -0,0 +1,25 @@
+import "reflect-metadata";
+
+const QUALIFIER_KEY = Symbol("xtaskjs:qualifier");
+
+export function Qualifier(name: string) {
+    return function (target: any, propertyKey: string | symbol | undefined, parameterIndex?: number) {
+        if(parameterIndex !== undefined){
+            // Parameter decorator
+            const existingQualifiers = Reflect.getMetadata(QUALIFIER_KEY, target) || {};
+            existingQualifiers[parameterIndex] = name;
+            Reflect.defineMetadata(QUALIFIER_KEY, existingQualifiers, target);
+        }
+    };
+}
+
+export function getQualifier(target: any, propertyKey?: string | symbol): string | undefined {
+    if(propertyKey){
+        return Reflect.getMetadata(QUALIFIER_KEY, target, propertyKey);
+    }
+    return undefined;
+}
+
+export function getConstructorQualifiers(target: any):Record<number,string>| undefined {
+    return Reflect.getMetadata(QUALIFIER_KEY, target);
+}

package/packages/core/src/di/stereotypes.ts

@@ -0,0 +1,10 @@
+import { Component, ComponentOptions } from "./component";  
+
+export const Service = (options: Omit<ComponentOptions, "type"> = {}) =>
+    Component({ ...options, type: "service" });
+
+export const Controller = (options: Omit<ComponentOptions, "type"> = {}) =>
+    Component({ ...options, type: "controller" });
+
+export const Repository = (options: Omit<ComponentOptions, "type"> = {}) =>
+    Component({ ...options, type: "repository" });

package/packages/core/src/index.ts

@@ -0,0 +1,5 @@
+import 'reflect-metadata';
+export * from "./bootstrap";
+export * from "./kernel";
+export * from "./di";
+export * from "./server";

package/packages/core/src/kernel/index.ts

@@ -0,0 +1,2 @@
+export * from './kernel';
+export * from './kernellisteners';

package/packages/core/src/kernel/kernel.ts

@@ -0,0 +1,31 @@
+import "reflect-metadata";
+import { Container } from "@xtaskjs/core";
+import { Logger } from "@xtaskjs/common";
+
+export class Kernel {
+ 
+    private container:Container;
+    private logger:Logger;
+
+    constructor(){
+    }
+    async boot(): Promise<void> {
+        // Bootstrapping logic here
+        this.container = new Container();
+        // Autoload components from the "packages" directory
+        await this.container.autoload("packages");
+
+        this.logger = await this.container.get(Logger);
+        // Simulate some async operation
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        this.logger.info("🚀 Kernel started successfully.");
+    }
+
+     async getContainer(): Promise<Container> {
+        return this.container;
+    }
+
+    
+
+}
+

package/packages/core/src/kernel/kernellisteners.ts

@@ -0,0 +1,36 @@
+import "reflect-metadata";
+import { OnEvent , ApplicationRunner,  CommandLineRunner } from "@xtaskjs/common";
+
+
+// Clase que escucha eventos del ciclo de vida
+export class KernelListeners {
+  @OnEvent("starting")
+  onStarting() {
+    console.log("[Lifecycle] Starting...");
+  }
+
+  @OnEvent("ready")
+  onReady() {
+    console.log("[Lifecycle] Application ready!");
+  }
+
+  @ApplicationRunner(5)
+  async afterStart() {
+    console.log("[Runner] ApplicationRunner ejecutado después de arrancar Kernel");
+  }
+
+  @CommandLineRunner(0)
+  async cli(args: string[]) {
+    console.log("[Runner] CommandLineRunner con args:", args);
+  }
+
+  @OnEvent("memoryReport")
+  memory(mem: NodeJS.MemoryUsage) {
+    console.log("[Metrics] Heap MB:", (mem.heapUsed / 1024 / 1024).toFixed(2));
+  }
+
+  @OnEvent("cpuReport")
+  cpu(calc: NodeJS.CpuUsage){
+    console.log("CPU", (calc));
+  }
+}

package/packages/core/src/server/application-lifecycle.ts

@@ -0,0 +1,85 @@
+import { LifeCyclePhase } from "@xtaskjs/common";
+import *  as os from "os";
+import * as process from "process";
+
+interface Listener{
+    fn: (...args: any[]) => any | Promise<any>;
+    priority:number;
+}
+
+export class ApplicationLifeCycle {
+    private listeners: Map<LifeCyclePhase, Listener[]> = new Map();
+    private metricsInterval?: NodeJS.Timeout;
+    private runners : { type: "ApplicationRunner" | "CommandLineRunner"; priority:number; fn:(args?:string[]) => any }[] = [];
+
+    constructor() {}
+
+    public on(event: LifeCyclePhase, Listener: (...args: any[]) => any | Promise<any>, 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));
+    }
+
+    public registerRunner(fn: (args?:string[]) => any, type: "ApplicationRunner" | "CommandLineRunner" = "ApplicationRunner", priority = 0) {
+        this.runners.push({ fn, type, priority});
+        this.runners.sort((a,b) => b.priority - a.priority);
+    }
+    
+    public async emit(event: LifeCyclePhase, payload?:any) {
+        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);
+                }
+            }
+        }
+    }
+
+    public async runRunners(type: "ApplicationRunner" | "CommandLineRunner") {
+        for (const runner of this.runners.filter(r => r.type === type)) {
+            await Promise.resolve(runner.fn(process.argv.slice(2)));
+        }
+    }
+
+    public async boot(startFn: () => Promise<void>) {
+       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;
+        }
+            
+    }
+
+    public async stop() {
+        if(this.metricsInterval){
+            clearInterval(this.metricsInterval);
+            this.metricsInterval = undefined;
+        }
+    }
+
+}

package/packages/core/src/server/index.ts

@@ -0,0 +1,3 @@
+export * from "./application-lifecycle";
+export * from "./registereventhandlers";
+export * from "../../../common/src/types/runnermeta";

package/packages/core/src/server/registereventhandlers.ts

@@ -0,0 +1,18 @@
+import "reflect-metadata";
+import { ApplicationLifeCycle } from "./application-lifecycle";
+import { EventHandlerMeta } from "@xtaskjs/common";
+import { RunnerMeta } from "../../../common/src/types/runnermeta";
+import { HANDLERS_KEY, RUNNERS_KEY } from "@xtaskjs/common";
+
+
+export function registerEventHandlers(instance: any, app:ApplicationLifeCycle) {
+  const handlers: EventHandlerMeta[] = Reflect.getMetadata(HANDLERS_KEY, instance.constructor) || [];
+  for (const { phase, method, priority } of handlers.sort((a, b) => b.priority - a.priority)) {
+    app.on(phase, async (...args) => (instance as any)[method](...args), priority);
+  }
+
+  const runners: RunnerMeta[] = Reflect.getMetadata(RUNNERS_KEY, instance.constructor) || [];
+  for (const { type, method, priority } of runners.sort((a, b) => b.priority - a.priority)) {
+    app.registerRunner((args) => (instance as any)[method](...args), type, priority);
+  }
+}

package/packages/core/test/di/autowired.test.ts

@@ -0,0 +1,83 @@
+import { Container, Service, AutoWired } from "../../src/di/index";
+
+@Service()
+class Logger {
+    log(message: string):string {
+        return `Log: ${message}`;
+    }
+}
+
+@Service()
+class Database {
+    query(sql: string):string {
+        return `Result of "${sql}"`;
+    }
+}
+
+@Service()
+class UserService {
+    @AutoWired()
+    logger!: Logger;
+
+    @AutoWired()
+    database!: Database;
+
+    getUser(id: number):string {
+        this.logger.log(`Fetching user with id: ${id}`);
+        return this.database.query(`SELECT * FROM users WHERE id = ${id}`);
+    }
+}
+
+@Service()
+class OptionalDependencyService {
+    @AutoWired({ required: false })
+    optionalLogger?: Logger;
+
+   hasLogger(): boolean {
+        return this.optionalLogger !==undefined;
+    }
+}
+
+describe("AutoWired Decorator", () => {
+   let container:Container;
+   
+   beforeEach(() => {
+        container = new 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/packages/core/test/di/container.test.ts

@@ -0,0 +1,49 @@
+import { Container, Service, AutoWired } from "../../src/di/index";
+
+@Service()
+class TestService{
+    getValue():number {
+        return 42;
+    }   
+}
+
+
+
+describe("Container", () => {
+    let container : Container
+    
+    beforeEach(() => {
+        container = new 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/packages/core/test/di/qualifier.test.ts

@@ -0,0 +1,60 @@
+import { Container, Service, AutoWired, Qualifier } from "../../src/di/index";
+
+interface INotificiationService{
+    send(message:string):string;
+}
+
+@Service({name: "emailNotificer"})
+class EmailNotificationService implements INotificiationService{
+    send(message: string):string {
+        return `Email sent: ${message}`;
+    }
+}
+
+@Service({name: "smsNotificer"})
+class SMSNotificationService implements INotificiationService{
+    send(message: string):string {
+        return `SMS sent: ${message}`;
+    }
+}
+
+@Service()
+class OrderService {
+    constructor(
+        @Qualifier("emailNotificer") public emailService: INotificiationService,
+        @Qualifier("smsNotificer") public smsService: INotificiationService
+    ){}
+}
+
+describe ("Qualifier Decorator", () => {
+    let container:Container;
+    
+    beforeEach(() => {
+          container = new 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<EmailNotificationService>("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/packages/core/test/logger/logger.test.ts

@@ -0,0 +1,11 @@
+import { Logger } from "@xtaskjs/common";
+
+describe("Logger", ()=> {
+    it ("Should print logs", () =>{
+        const logger = new Logger();
+        const spy = jest.spyOn(console, "log").mockImplementation();
+        logger.info("hello");
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining("hello"));
+        spy.mockRestore();
+    })
+})

package/packages/core/test/server/applicationlifecycle.test.ts

@@ -0,0 +1,13 @@
+import { OnEvent } from "@xtaskjs/common";
+import { Service } from "packages/core/src";
+
+@Service()
+class TestLifeCycleListener {
+    public events: string []=[];
+
+    @OnEvent('starting', 10)
+    async onStarting(){
+        this.events.push("starting");
+    }
+    
+}

package/packages/core/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2021",
+    "module": "commonjs",
+    "rootDir": "./src",
+    "outDir": "dist",
+    "esModuleInterop": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "baseUrl": ".",
+    "paths":{
+      "@xtaskjs/common": ["../../dist/packages/common"],
+      "@xtaskjs/common/*": ["../../dist/packages/common/*"]
+    },
+    "declaration": true
+  },
+  "include": ["packages/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "CommonJS",
+    "rootDir": "./",
+    "outDir": "dist",
+    "esModuleInterop": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "baseUrl": "./",
+    "paths": {
+      "@xtaskjs/common": ["packages/common"],
+      "@xtaskjs/core": ["packages/core"]
+    }
+  },
+  "include": ["packages/**/*","packages/**/**/*","packages/**/**/**/*"],
+  "exclude": ["node_modules", "dist"]
+}