xtaskjs 1.0.0

package/packages/common/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@xtaskjs/common",
+  "version": "1.0.0",
+  "description": "xtaskjs - modern, fast, node.js web framework (@common)",
+  "author": "Javier Rodríguez Soler",
+  "homepage": "https://xtaskjs.com",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test":" jest --passWithNoTests"
+  },
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/xtaskjs"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/xtaskjs/xtaskjs.git",
+    "directory": "packages/common"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "dependencies": {
+     },
+  "peerDependencies": {
+    "reflect-metadata": "^0.1.12 || ^0.2.0"
+      },
+  "peerDependenciesMeta": {
+    "class-validator": {
+      "optional": true
+    },
+    "class-transformer": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@jest/globals": "^30.1.2",
+    "@types/express": "^5.0.3",
+    "@types/jest": "^30.0.0",
+    "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/src/decorators/core/server/applicationrunner.ts

@@ -0,0 +1,10 @@
+import { RunnerMeta } from '@xtaskjs/core';
+import { RUNNERS_KEY } from './constants';
+
+export function ApplicationRunner(priority = 0): MethodDecorator {
+  return (target, propertyKey) => {
+    const runners: RunnerMeta[] = Reflect.getMetadata(RUNNERS_KEY, target.constructor) || [];
+    runners.push({ type: "ApplicationRunner", method: propertyKey, priority });
+    Reflect.defineMetadata(RUNNERS_KEY, runners, target.constructor);
+  };
+}

package/packages/common/src/decorators/core/server/commandlinerunner.ts

@@ -0,0 +1,10 @@
+import { RunnerMeta } from '@xtaskjs/core';
+import { RUNNERS_KEY } from './constants';
+
+export function CommandLineRunner(priority = 0): MethodDecorator {
+  return (target, propertyKey) => {
+    const runners: RunnerMeta[] = Reflect.getMetadata(RUNNERS_KEY, target.constructor) || [];
+    runners.push({ type: "CommandLineRunner", method: propertyKey, priority });
+    Reflect.defineMetadata(RUNNERS_KEY, runners, target.constructor);
+  };
+}

package/packages/common/src/decorators/core/server/constants.ts

@@ -0,0 +1,2 @@
+export const HANDLERS_KEY = Symbol("xtaskjs:eventHandlers");
+export const RUNNERS_KEY = Symbol("xtaskjs:runners");

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

@@ -0,0 +1,4 @@
+export * from './onevent';
+export * from './applicationrunner';
+export * from './commandlinerunner';
+export * from './constants';

package/packages/common/src/decorators/core/server/onevent.ts

@@ -0,0 +1,10 @@
+import { HANDLERS_KEY } from "./constants";
+import { EventHandlerMeta , LifeCyclePhase } from "../../../types";
+
+export function OnEvent(phase: LifeCyclePhase, priority = 0): MethodDecorator {
+  return (target, propertyKey) => {
+    const handlers: EventHandlerMeta[] = Reflect.getMetadata(HANDLERS_KEY, target.constructor) || [];
+    handlers.push({ phase, method: propertyKey, priority });
+    Reflect.defineMetadata(HANDLERS_KEY, handlers, target.constructor);
+  };
+}

package/packages/common/src/index.ts

@@ -0,0 +1,5 @@
+import 'reflect-metadata';
+export * from "./logger";
+export * from "./decorators/core/server";
+export * from "./types";
+export { HANDLERS_KEY , RUNNERS_KEY} from "./decorators/core/server/constants";

package/packages/common/src/logger/index.ts

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

package/packages/common/src/logger/logger.ts

@@ -0,0 +1,26 @@
+import { Service } from '../../../core/src/di/stereotypes';
+import { PostConstruct } from '../../../core/src/di/lifecycle';
+
+@Service({ scope: "singleton" })
+export class Logger {
+
+    constructor() {}
+    
+  @PostConstruct()
+  init() {
+    console.log("Logger Initialized");
+  }
+
+    
+    info(message: string): void {
+        console.log(`INFO: ${message}`);
+    }
+
+    warn(message: string): void {
+        console.warn(`WARN: ${message}`);
+    }
+
+    error(message: string): void {
+        console.error(`ERROR: ${message}`);
+    }
+}

package/packages/common/src/types/eventhandlermeta.ts

@@ -0,0 +1,7 @@
+import { LifeCyclePhase } from "./lifecycle-events";
+
+export interface EventHandlerMeta {
+  phase: LifeCyclePhase;
+  method: string | symbol;
+  priority: number;
+}

package/packages/common/src/types/index.ts

@@ -0,0 +1,3 @@
+export * from "./lifecycle-events";
+export * from "./runnermeta";
+export * from "./eventhandlermeta";

package/packages/common/src/types/lifecycle-events.ts

@@ -0,0 +1,10 @@
+export type LifeCyclePhase = 
+| "starting"
+| "environmentPrepared"
+| "contextPrepared"
+| "serverStarting"
+| "serverStarted"
+| "ready"
+| "error"
+| "memoryReport"
+| "cpuReport" ;

package/packages/common/src/types/runnermeta.ts

@@ -0,0 +1,5 @@
+export interface RunnerMeta {
+  type: "ApplicationRunner" | "CommandLineRunner";
+  method: string | symbol;
+  priority: number;
+}

package/packages/common/test/logger/logger.test.ts

@@ -0,0 +1,11 @@
+import { Logger } from "../../src/logger/logger";
+
+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/common/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2021",
+    "module": "commonjs",
+    "rootDir": "./src",
+    "outDir": "dist",
+    "esModuleInterop": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/packages/core/README.md

@@ -0,0 +1,21 @@
+# @xtaskjs/core
+
+Core package for xtaskjs, a modern, fast Node.js web framework.
+
+## Installation
+```bash
+npm install @xtaskjs/core
+```
+
+## Usage
+```typescript
+import { ... } from '@xtaskjs/core';
+```
+
+## Features
+- Dependency Injection
+- Application Lifecycle
+- Kernel and Server utilities
+
+## Documentation
+See [xtaskjs.com](https://xtaskjs.com) for full documentation.

package/packages/core/babel.config.js

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

package/packages/core/index.ts

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

package/packages/core/jest.config.js

@@ -0,0 +1,15 @@
+const { createDefaultPreset } = require("ts-jest");
+
+const tsJestTransformCfg = createDefaultPreset().transform;
+
+/** @type {import("jest").Config} **/
+module.exports = {
+  testEnvironment: "node",
+  transform: {
+    ...tsJestTransformCfg,
+  },
+  moduleNameMapper: {
+    "^@xtaskjs/common$": "<rootDir>/../common/dist/index.js",
+    "^@xtaskjs/common/(.*)$": "<rootDir>/../common/dist/$1"
+  },
+};

package/packages/core/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@xtaskjs/core",
+  "version": "1.0.0",
+  "description": "xtaskjs - modern, fast, node.js web framework (@core)",
+  "author": "Javier Rodríguez Soler",
+  "homepage": "https://xtaskjs.com",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test":" jest --passWithNoTests"
+  },
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/xtaskjs"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/xtaskjs/xtaskjs.git",
+    "directory": "packages/core"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "dependencies": {
+      "@xtaskjs/common": "^1.0.0"
+     },
+  "peerDependencies": {
+    "reflect-metadata": "^0.1.12 || ^0.2.0"
+      },
+  "peerDependenciesMeta": {
+    "class-validator": {
+      "optional": true
+    },
+    "class-transformer": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@jest/globals": "^30.1.2",
+    "@types/express": "^5.0.3",
+    "@types/jest": "^30.0.0",
+    "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/core/src/bootstrap.ts

@@ -0,0 +1,11 @@
+import "reflect-metadata";
+import { ApplicationLifeCycle, Kernel, KernelListeners, registerEventHandlers } from "@xtaskjs/core";
+
+export async function Bootstrap(): Promise<Kernel> {
+    const lifecycle = new ApplicationLifeCycle();
+    const kernel = new Kernel();
+    const listeners = new KernelListeners(); 
+    registerEventHandlers(listeners, lifecycle);
+    await lifecycle.boot(() => kernel.boot());
+    return kernel;
+}

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

@@ -0,0 +1,56 @@
+import "reflect-metadata";
+
+const AUTOWIRED_KEY = Symbol("xtaskjs:autowired");
+const AUTOWIRED_PROPS_KEY = Symbol("xtaskjs:autowired:props");
+
+export interface AutoWiredMetaData {
+    type: any;
+    required: boolean;
+    qualifier?: string;
+}
+
+export function AutoWired(options: { required?: boolean; qualifier?: string } = {}) {
+    return function (target: any, propertyKey: string | symbol) {
+        const type = Reflect.getMetadata("design:type", target, propertyKey);
+        const metaData: AutoWiredMetaData = {
+            type,
+            required: options.required !== false,
+            qualifier: options.qualifier,
+        };
+
+        // Store metadata for the property
+        Reflect.defineMetadata(AUTOWIRED_KEY, metaData, target, propertyKey);
+
+        // Store list of autowired properties on the class prototype
+        const existingProps= 
+            Reflect.getMetadata(AUTOWIRED_PROPS_KEY, target.constructor) || [];
+        if (!existingProps.includes(propertyKey)) {
+            existingProps.push(propertyKey);
+            Reflect.defineMetadata(AUTOWIRED_PROPS_KEY, existingProps, target.constructor);
+        }
+    };
+}
+
+export function getAutoWiredProperties(target: any): Map<string | symbol, AutoWiredMetaData>{
+
+    const properties = new Map<string | symbol, AutoWiredMetaData>();
+    let currentClass = target.contructor;
+
+    while (currentClass && currentClass !== Object) {
+        const autowiredProps = Reflect.getMetadata(AUTOWIRED_PROPS_KEY, currentClass) || [];
+        const prototype = currentClass.prototype;
+
+        autowiredProps.forEach((prop: string | symbol) => {
+                const metaData = Reflect.getMetadata(AUTOWIRED_KEY, prototype, prop);
+                if (metaData && !properties.has(prop)) {
+                    properties.set(prop, metaData);
+                }
+            });
+
+        currentClass = Object.getPrototypeOf(currentClass);
+          
+    }
+
+    return properties;
+    
+}

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

@@ -0,0 +1,34 @@
+import "reflect-metadata";
+
+export type ComponentType = "service" | "controller" | "repository";
+export type ScoreType = "singleton" | "transient";
+
+const COMPONENT_KEY = Symbol("xtaskjs:component");
+
+export interface ComponentMetadata {
+    scope ?: "singleton" | "transient";
+    condition?:() => boolean;
+    name?: string;
+    primary?: boolean;
+}
+
+export interface ComponentOptions {
+    type?: ComponentType;
+    scope?: ScoreType;
+    condition?:() => boolean;
+    name?: string;
+    primary?: boolean;
+}
+
+export function Component (options: ComponentOptions = {}) {
+    return function (target: any) {
+        Reflect.defineMetadata(COMPONENT_KEY, options, target);
+    };
+}
+
+export function getComponentMetadata(target: any): ComponentOptions | undefined {
+    return Reflect.getMetadata(COMPONENT_KEY, target);
+}
+
+export const Service  = (meta: ComponentMetadata = {}) => Component(meta);
+export const Repository  = (meta: ComponentMetadata = {}) => Component(meta);

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

@@ -0,0 +1,216 @@
+import "reflect-metadata"
+import { ComponentMetadata, getComponentMetadata } from "./component";
+import { getPostConstructMethod, getPreDestroyMethod } from "./lifecycle";  
+import { readdirSync , statSync } from "fs";
+import { join } from "path";
+import { ManagedInstance } from "./managedinstance";
+import { Project } from "ts-morph";
+import { getAutoWiredProperties } from "./autowired";
+import { getConstructorQualifiers } from "./qualifier";
+import { registerEventHandlers} from "../server";
+import { HANDLERS_KEY, RUNNERS_KEY } from "@xtaskjs/common";
+
+
+export class Container{
+    private providers = new Map<any, () => any>();
+    private singletons = new Map<any, any>();
+    private nameToType = new Map<string, any>();
+    private typeToNames = new Map<any, string[]>();
+    private primaryBeans = new Map<any, any>();
+    private resolving = new Set<any>();
+    public managedInstances : ManagedInstance[] = [];
+
+    // SCAN FOLDER BASE DIR FOR @Service() AND @Component()
+
+    async autoload(baseDir = "packages"){
+        const files = await this.scanDir(join(process.cwd(), baseDir));
+    
+        for (const file of files) {
+            const name = file.toString();
+            if (name.includes("test")) continue; //skip test files
+            if (name.endsWith("d.ts")) continue; // skip TypeScript declarations Files.
+            if (name.includes("js")) continue; //skip configuration files
+            if (name.includes("json")) continue; //skip configuration files
+            if (name.includes("index.ts")) continue; //skip export files
+            const module = await import(file);
+            const project = new Project();
+            const sourceFile = project.addSourceFileAtPath(file);
+            const classes = sourceFile.getClasses();
+            
+            for (const cls of classes) {
+               if (cls.getDecorator("Service") || cls.getDecorator("Component") || cls.getDecorator("Controller") || cls.getDecorator("Repository")) {
+                    const className = cls.getName();
+                    if (className && module[className]){
+                        const classConstructor = module[className];
+                        const metaData = getComponentMetadata(classConstructor) || { scope: "singleton"};
+                        const beanName = metaData.name || className;
+                        this.registerWithName(classConstructor, metaData, beanName);
+                    }
+                }
+            }
+        } 
+    }   
+        
+ 
+    public registerWithName(target: any, meta: ComponentMetadata, name?: string){
+        if (name){
+             this.nameToType.set(name, target);
+             const existingNames = this.typeToNames.get(target) || [];
+             existingNames.push(name);
+             this.typeToNames.set(target, existingNames);
+        }
+
+        if (meta.primary){
+            this.primaryBeans.set(target,target);
+        }
+
+        this.register(target, meta);
+    
+    }
+
+    // Register aa class with the container
+    
+    public register(target: any, meta: ComponentMetadata){
+        const paramTypes: any[] =
+            Reflect.getMetadata("design:paramtypes", target) || [];
+
+        console.log(`Registering component: ${target.name} with dependencies:`, paramTypes.map(t => t?.name || 'unknown'));
+        
+        const provider = () => {
+            if (this.resolving.has(target)) {
+                const resolvingNames = Array.from(this.resolving).map(t => t.name || 'unknown').join(" -> ");
+                throw new Error(`Circular dependency detected: ${resolvingNames} -> ${target.name}`);
+            }
+            
+            this.resolving.add(target);
+
+            
+            try{
+                const qualifiers = getConstructorQualifiers(target);
+                const dependencies = paramTypes.map((dep, index) => {
+                    const qualifier = qualifiers?.[index];
+                    return this.getWithQualifier(dep, qualifier);
+                });
+                
+                const instance = new target(...dependencies);
+                
+                this.injectAutoWiredFields(instance);
+
+                //PostConstruct
+                const postMethod = getPostConstructMethod(instance);
+                if (postMethod && typeof instance[postMethod] === "function") {
+                    instance[postMethod]();
+                }
+
+                //PreDestroy
+                const preMethod = getPreDestroyMethod(instance);
+                if (preMethod && typeof instance[preMethod] === "function") {
+                    this.managedInstances.push({
+                        instance,
+                        preDestroy: () => instance[preMethod](),
+                    });
+                }
+            
+            return instance;
+        } finally {
+            this.resolving.delete(target);
+        }
+    }
+  
+    if (meta.scope === "transient") {
+            this.providers.set(target, provider);
+        } else { //singleton by default
+            this.providers.set(target,()=> {
+                if (!this.singletons.has(target)) {
+                    const instance = provider();
+                    this.singletons.set(target, instance);
+                }
+              return this.singletons.get(target);
+            })
+        }
+    }
+
+    public getByName<T>(name: string): T {
+        const type = this.nameToType.get(name);
+        if (!type) {
+            throw new Error(`No component found with name: ${name}`);
+        }
+        return this.get(type);
+    }
+
+    private getWithQualifier<T>(type: new (...args: any[]) => T, qualifier?: string): T {
+        if(qualifier){
+            return this.getByName<T>(qualifier);
+        }
+        return this.get(type);
+    }
+
+    private injectAutoWiredFields(instance: any) {
+        const autoWiredProperties = getAutoWiredProperties(instance);
+        autoWiredProperties.forEach((metaData, propertyKey) => {
+            try {
+                let value;
+                if (metaData.qualifier) {
+                    value = this.getByName(metaData.qualifier);
+                } else {
+                    value = this.get(metaData.type);
+                } 
+                instance[propertyKey] = value;
+            }catch (error) {
+                if (metaData.required) {
+                    throw new Error(`Failed to inject required dependency for property "${String(propertyKey)}": ${error.message}`);
+                }
+            }
+        });
+    }
+
+    // Get instance of class
+    get<T>(target: new (...args: any[]) => T): T {
+        const provider = this.providers.get(target);
+        if (!provider) {
+            throw new Error(`No provider found for ${target.name}`);
+        }
+        return provider();
+    }
+
+    // Execute all @PreDestroy in reverse order
+
+    destroy() {
+        this.managedInstances.reverse().forEach((m) => m.preDestroy?.());
+        this.managedInstances = [];
+        this.singletons.clear();
+        this.providers.clear();
+    }
+    
+    // Scan folder recursively for .ts or .js files
+    public async scanDir(dir: string): Promise<string[]> {
+        let results: string[] = [];
+        for (const file of readdirSync(dir)) {
+            const full = join (dir, file);
+            const stat = statSync(full);
+            if (stat && stat.isDirectory()) {
+                const res = await this.scanDir(full);
+                results = results.concat(res);
+            } else if (/\.(ts|js)$/.test(file)) {
+                results.push(full);
+            }
+        }
+        return results;
+    }
+
+
+    public registerLifeCycleListeners(app: any)
+    { 
+        
+        for (const [type] of this.providers.entries()){
+            // Check if class has lifecycle decorators
+            const handlers = Reflect.getMetadata(HANDLERS_KEY, type) || [];
+            const runners =  Reflect.getMetadata(RUNNERS_KEY, type) || [];
+
+            if(handlers.length > 0 || runners.length > 0){
+                const instance = this.get(type);
+                registerEventHandlers(instance, app);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,8 @@
+export {Component, ComponentOptions} from "./component"
+export {Container} from "./container"
+export * from "./lifecycle"
+export {ManagedInstance} from "./managedinstance"
+export {getComponentMetadata} from "./component"
+export * from "./stereotypes"   
+export * from "./autowired"
+export * from "./qualifier"

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

@@ -0,0 +1,25 @@
+import "reflect-metadata";
+
+export const  POST_CONSTRUCT_KEY = Symbol("post_construct");
+export const PRE_DESTROY_KEY = Symbol("pre_destroy");
+
+export function PostConstruct() {
+  return function (target: any, propertyKey: string) {
+    Reflect.defineMetadata(POST_CONSTRUCT_KEY, propertyKey, target);
+  };
+};
+
+
+export function PreDestroy() {
+    return function (target: any, propertyKey: string) {
+        Reflect.defineMetadata(PRE_DESTROY_KEY, propertyKey, target);
+    };  
+}
+
+export function getPostConstructMethod(target: any): string | undefined {
+    return Reflect.getMetadata(POST_CONSTRUCT_KEY, target);
+}
+
+export function getPreDestroyMethod(target: any): string | undefined {
+    return Reflect.getMetadata(PRE_DESTROY_KEY, target);
+}   

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

@@ -0,0 +1,4 @@
+export interface ManagedInstance<T = any> {
+    instance: T;
+    preDestroy?: ()=> void;
+}