xtaskjs 1.0.0

package/.github/workflows/publish.yml

@@ -0,0 +1,44 @@
+name: Publish Packages
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    env:
+      BROWSER: none
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Use Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: 'https://registry.npmjs.org/'
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Build all packages
+        run: npm run build
+
+      - name: Set up git user
+        run: |
+          git config --global user.name 'github-actions[bot]'
+          git config --global user.email 'github-actions[bot]@users.noreply.github.com'
+
+      - name: Bump versions and publish packages
+        run: |
+          npx lerna version --conventional-commits --yes
+          npx lerna publish from-package --yes
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+
+      - name: Push changes
+        run: git push --follow-tags origin main
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

package/app.ts

@@ -0,0 +1,7 @@
+import {Bootstrap} from "@xtaskjs/core";
+
+async function main() {
+    const kernel = await Bootstrap();}
+main().catch(err => {
+    console.error("Error starting the application:", err);
+}); 

package/babel.config.js

@@ -0,0 +1,4 @@
+module.exports = {
+    presets: ['@babel/preset-env'],
+    plugins: ['@babel/plugin-transform-modules-commonjs']
+}

package/dist/packages/common/index.js

@@ -0,0 +1,17 @@
+"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("./src"), exports);

package/dist/packages/common/src/decorators/core/server/applicationrunner.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplicationRunner = ApplicationRunner;
+const constants_1 = require("./constants");
+function ApplicationRunner(priority = 0) {
+    return (target, propertyKey) => {
+        const runners = Reflect.getMetadata(constants_1.RUNNERS_KEY, target.constructor) || [];
+        runners.push({ type: "ApplicationRunner", method: propertyKey, priority });
+        Reflect.defineMetadata(constants_1.RUNNERS_KEY, runners, target.constructor);
+    };
+}

package/dist/packages/common/src/decorators/core/server/commandlinerunner.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandLineRunner = CommandLineRunner;
+const constants_1 = require("./constants");
+function CommandLineRunner(priority = 0) {
+    return (target, propertyKey) => {
+        const runners = Reflect.getMetadata(constants_1.RUNNERS_KEY, target.constructor) || [];
+        runners.push({ type: "CommandLineRunner", method: propertyKey, priority });
+        Reflect.defineMetadata(constants_1.RUNNERS_KEY, runners, target.constructor);
+    };
+}

package/dist/packages/common/src/decorators/core/server/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RUNNERS_KEY = exports.HANDLERS_KEY = void 0;
+exports.HANDLERS_KEY = Symbol("xtaskjs:eventHandlers");
+exports.RUNNERS_KEY = Symbol("xtaskjs:runners");

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

@@ -0,0 +1,20 @@
+"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("./onevent"), exports);
+__exportStar(require("./applicationrunner"), exports);
+__exportStar(require("./commandlinerunner"), exports);
+__exportStar(require("./constants"), exports);

package/dist/packages/common/src/decorators/core/server/onevent.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnEvent = OnEvent;
+const constants_1 = require("./constants");
+function OnEvent(phase, priority = 0) {
+    return (target, propertyKey) => {
+        const handlers = Reflect.getMetadata(constants_1.HANDLERS_KEY, target.constructor) || [];
+        handlers.push({ phase, method: propertyKey, priority });
+        Reflect.defineMetadata(constants_1.HANDLERS_KEY, handlers, target.constructor);
+    };
+}

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

@@ -0,0 +1,24 @@
+"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 });
+exports.RUNNERS_KEY = exports.HANDLERS_KEY = void 0;
+require("reflect-metadata");
+__exportStar(require("./logger"), exports);
+__exportStar(require("./decorators/core/server"), exports);
+__exportStar(require("./types"), exports);
+var constants_1 = require("./decorators/core/server/constants");
+Object.defineProperty(exports, "HANDLERS_KEY", { enumerable: true, get: function () { return constants_1.HANDLERS_KEY; } });
+Object.defineProperty(exports, "RUNNERS_KEY", { enumerable: true, get: function () { return constants_1.RUNNERS_KEY; } });

package/dist/packages/common/src/logger/index.js

@@ -0,0 +1,17 @@
+"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("./logger"), exports);

package/dist/packages/common/src/logger/logger.js

@@ -0,0 +1,40 @@
+"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.Logger = void 0;
+const stereotypes_1 = require("../../../core/src/di/stereotypes");
+const lifecycle_1 = require("../../../core/src/di/lifecycle");
+let Logger = class Logger {
+    constructor() { }
+    init() {
+        console.log("Logger Initialized");
+    }
+    info(message) {
+        console.log(`INFO: ${message}`);
+    }
+    warn(message) {
+        console.warn(`WARN: ${message}`);
+    }
+    error(message) {
+        console.error(`ERROR: ${message}`);
+    }
+};
+exports.Logger = Logger;
+__decorate([
+    (0, lifecycle_1.PostConstruct)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], Logger.prototype, "init", null);
+exports.Logger = Logger = __decorate([
+    (0, stereotypes_1.Service)({ scope: "singleton" }),
+    __metadata("design:paramtypes", [])
+], Logger);

package/dist/packages/common/src/types/eventhandlermeta.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/packages/common/src/types/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("./lifecycle-events"), exports);
+__exportStar(require("./runnermeta"), exports);
+__exportStar(require("./eventhandlermeta"), exports);

package/dist/packages/common/src/types/lifecycle-events.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/packages/common/src/types/runnermeta.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

package/dist/packages/core/index.js

@@ -0,0 +1,17 @@
+"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("./src"), exports);

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bootstrap = Bootstrap;
+require("reflect-metadata");
+const core_1 = require("@xtaskjs/core");
+async function Bootstrap() {
+    const lifecycle = new core_1.ApplicationLifeCycle();
+    const kernel = new core_1.Kernel();
+    const listeners = new core_1.KernelListeners();
+    (0, core_1.registerEventHandlers)(listeners, lifecycle);
+    await lifecycle.boot(() => kernel.boot());
+    return kernel;
+}

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoWired = AutoWired;
+exports.getAutoWiredProperties = getAutoWiredProperties;
+require("reflect-metadata");
+const AUTOWIRED_KEY = Symbol("xtaskjs:autowired");
+const AUTOWIRED_PROPS_KEY = Symbol("xtaskjs:autowired:props");
+function AutoWired(options = {}) {
+    return function (target, propertyKey) {
+        const type = Reflect.getMetadata("design:type", target, propertyKey);
+        const metaData = {
+            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);
+        }
+    };
+}
+function getAutoWiredProperties(target) {
+    const properties = new Map();
+    let currentClass = target.contructor;
+    while (currentClass && currentClass !== Object) {
+        const autowiredProps = Reflect.getMetadata(AUTOWIRED_PROPS_KEY, currentClass) || [];
+        const prototype = currentClass.prototype;
+        autowiredProps.forEach((prop) => {
+            const metaData = Reflect.getMetadata(AUTOWIRED_KEY, prototype, prop);
+            if (metaData && !properties.has(prop)) {
+                properties.set(prop, metaData);
+            }
+        });
+        currentClass = Object.getPrototypeOf(currentClass);
+    }
+    return properties;
+}

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Repository = exports.Service = void 0;
+exports.Component = Component;
+exports.getComponentMetadata = getComponentMetadata;
+require("reflect-metadata");
+const COMPONENT_KEY = Symbol("xtaskjs:component");
+function Component(options = {}) {
+    return function (target) {
+        Reflect.defineMetadata(COMPONENT_KEY, options, target);
+    };
+}
+function getComponentMetadata(target) {
+    return Reflect.getMetadata(COMPONENT_KEY, target);
+}
+const Service = (meta = {}) => Component(meta);
+exports.Service = Service;
+const Repository = (meta = {}) => Component(meta);
+exports.Repository = Repository;

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

@@ -0,0 +1,225 @@
+"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.Container = void 0;
+require("reflect-metadata");
+const component_1 = require("./component");
+const lifecycle_1 = require("./lifecycle");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const ts_morph_1 = require("ts-morph");
+const autowired_1 = require("./autowired");
+const qualifier_1 = require("./qualifier");
+const server_1 = require("../server");
+const common_1 = require("@xtaskjs/common");
+class Container {
+    providers = new Map();
+    singletons = new Map();
+    nameToType = new Map();
+    typeToNames = new Map();
+    primaryBeans = new Map();
+    resolving = new Set();
+    managedInstances = [];
+    // SCAN FOLDER BASE DIR FOR @Service() AND @Component()
+    async autoload(baseDir = "packages") {
+        const files = await this.scanDir((0, path_1.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 Promise.resolve(`${file}`).then(s => __importStar(require(s)));
+            const project = new ts_morph_1.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 = (0, component_1.getComponentMetadata)(classConstructor) || { scope: "singleton" };
+                        const beanName = metaData.name || className;
+                        this.registerWithName(classConstructor, metaData, beanName);
+                    }
+                }
+            }
+        }
+    }
+    registerWithName(target, meta, name) {
+        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
+    register(target, meta) {
+        const paramTypes = 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 = (0, qualifier_1.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 = (0, lifecycle_1.getPostConstructMethod)(instance);
+                if (postMethod && typeof instance[postMethod] === "function") {
+                    instance[postMethod]();
+                }
+                //PreDestroy
+                const preMethod = (0, lifecycle_1.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);
+            });
+        }
+    }
+    getByName(name) {
+        const type = this.nameToType.get(name);
+        if (!type) {
+            throw new Error(`No component found with name: ${name}`);
+        }
+        return this.get(type);
+    }
+    getWithQualifier(type, qualifier) {
+        if (qualifier) {
+            return this.getByName(qualifier);
+        }
+        return this.get(type);
+    }
+    injectAutoWiredFields(instance) {
+        const autoWiredProperties = (0, autowired_1.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(target) {
+        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
+    async scanDir(dir) {
+        let results = [];
+        for (const file of (0, fs_1.readdirSync)(dir)) {
+            const full = (0, path_1.join)(dir, file);
+            const stat = (0, fs_1.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;
+    }
+    registerLifeCycleListeners(app) {
+        for (const [type] of this.providers.entries()) {
+            // Check if class has lifecycle decorators
+            const handlers = Reflect.getMetadata(common_1.HANDLERS_KEY, type) || [];
+            const runners = Reflect.getMetadata(common_1.RUNNERS_KEY, type) || [];
+            if (handlers.length > 0 || runners.length > 0) {
+                const instance = this.get(type);
+                (0, server_1.registerEventHandlers)(instance, app);
+            }
+        }
+    }
+}
+exports.Container = Container;

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

@@ -0,0 +1,27 @@
+"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 });
+exports.getComponentMetadata = exports.Container = exports.Component = void 0;
+var component_1 = require("./component");
+Object.defineProperty(exports, "Component", { enumerable: true, get: function () { return component_1.Component; } });
+var container_1 = require("./container");
+Object.defineProperty(exports, "Container", { enumerable: true, get: function () { return container_1.Container; } });
+__exportStar(require("./lifecycle"), exports);
+var component_2 = require("./component");
+Object.defineProperty(exports, "getComponentMetadata", { enumerable: true, get: function () { return component_2.getComponentMetadata; } });
+__exportStar(require("./stereotypes"), exports);
+__exportStar(require("./autowired"), exports);
+__exportStar(require("./qualifier"), exports);

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRE_DESTROY_KEY = exports.POST_CONSTRUCT_KEY = void 0;
+exports.PostConstruct = PostConstruct;
+exports.PreDestroy = PreDestroy;
+exports.getPostConstructMethod = getPostConstructMethod;
+exports.getPreDestroyMethod = getPreDestroyMethod;
+require("reflect-metadata");
+exports.POST_CONSTRUCT_KEY = Symbol("post_construct");
+exports.PRE_DESTROY_KEY = Symbol("pre_destroy");
+function PostConstruct() {
+    return function (target, propertyKey) {
+        Reflect.defineMetadata(exports.POST_CONSTRUCT_KEY, propertyKey, target);
+    };
+}
+;
+function PreDestroy() {
+    return function (target, propertyKey) {
+        Reflect.defineMetadata(exports.PRE_DESTROY_KEY, propertyKey, target);
+    };
+}
+function getPostConstructMethod(target) {
+    return Reflect.getMetadata(exports.POST_CONSTRUCT_KEY, target);
+}
+function getPreDestroyMethod(target) {
+    return Reflect.getMetadata(exports.PRE_DESTROY_KEY, target);
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });