@deployforme/core 1.0.0

package/dist/context.d.ts

@@ -0,0 +1,7 @@
+import { RuntimeContext, HttpAdapter, Logger, DependencyContainer } from './types';
+export declare class DefaultLogger implements Logger {
+    log(message: string): void;
+    error(message: string): void;
+    warn(message: string): void;
+}
+export declare function createRuntimeContext(http: HttpAdapter, container?: DependencyContainer, logger?: Logger): RuntimeContext;

package/dist/context.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultLogger = void 0;
+exports.createRuntimeContext = createRuntimeContext;
+class DefaultLogger {
+    log(message) {
+        console.log(`[Deploy4Me] ${message}`);
+    }
+    error(message) {
+        console.error(`[Deploy4Me] ERROR: ${message}`);
+    }
+    warn(message) {
+        console.warn(`[Deploy4Me] WARN: ${message}`);
+    }
+}
+exports.DefaultLogger = DefaultLogger;
+function createRuntimeContext(http, container, logger) {
+    return {
+        http,
+        container,
+        logger: logger || new DefaultLogger()
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { Kernel } from './kernel';
+export { ModuleRegistry } from './module-registry';
+export { ModuleLoader } from './loader';
+export { createRuntimeContext, DefaultLogger } from './context';
+export * from './types';

package/dist/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.DefaultLogger = exports.createRuntimeContext = exports.ModuleLoader = exports.ModuleRegistry = exports.Kernel = void 0;
+var kernel_1 = require("./kernel");
+Object.defineProperty(exports, "Kernel", { enumerable: true, get: function () { return kernel_1.Kernel; } });
+var module_registry_1 = require("./module-registry");
+Object.defineProperty(exports, "ModuleRegistry", { enumerable: true, get: function () { return module_registry_1.ModuleRegistry; } });
+var loader_1 = require("./loader");
+Object.defineProperty(exports, "ModuleLoader", { enumerable: true, get: function () { return loader_1.ModuleLoader; } });
+var context_1 = require("./context");
+Object.defineProperty(exports, "createRuntimeContext", { enumerable: true, get: function () { return context_1.createRuntimeContext; } });
+Object.defineProperty(exports, "DefaultLogger", { enumerable: true, get: function () { return context_1.DefaultLogger; } });
+__exportStar(require("./types"), exports);

package/dist/kernel.d.ts

@@ -0,0 +1,13 @@
+import { RuntimeContext } from './types';
+export declare class Kernel {
+    private registry;
+    private loader;
+    private context;
+    private routeTracker;
+    constructor(context: RuntimeContext);
+    load(modulePath: string): Promise<void>;
+    unload(moduleName: string): Promise<void>;
+    reload(modulePath: string): Promise<void>;
+    list(): import("./types").ModuleMetadata[];
+    get(moduleName: string): import("./types").ModuleMetadata | undefined;
+}

package/dist/kernel.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Kernel = void 0;
+const module_registry_1 = require("./module-registry");
+const loader_1 = require("./loader");
+class Kernel {
+    constructor(context) {
+        this.routeTracker = new Map();
+        this.context = context;
+        this.registry = new module_registry_1.ModuleRegistry();
+        this.loader = new loader_1.ModuleLoader();
+    }
+    async load(modulePath) {
+        const module = await this.loader.load(modulePath);
+        // Unload existing module if present
+        if (this.registry.has(module.name)) {
+            await this.unload(module.name);
+        }
+        this.context.logger?.log(`Loading module: ${module.name}@${module.version}`);
+        // Track routes registered during module.register()
+        const routeIds = [];
+        const originalRegister = this.context.http.registerRoute.bind(this.context.http);
+        this.context.http.registerRoute = (definition) => {
+            routeIds.push(definition.id);
+            originalRegister(definition);
+        };
+        // Register module
+        module.register(this.context);
+        // Restore original registerRoute
+        this.context.http.registerRoute = originalRegister;
+        // Store in registry
+        this.registry.register(module, routeIds);
+        this.routeTracker.set(module.name, routeIds);
+        this.context.logger?.log(`Module loaded: ${module.name} (${routeIds.length} routes)`);
+    }
+    async unload(moduleName) {
+        const metadata = this.registry.get(moduleName);
+        if (!metadata) {
+            this.context.logger?.warn(`Module not found: ${moduleName}`);
+            return;
+        }
+        this.context.logger?.log(`Unloading module: ${moduleName}`);
+        // Call dispose if exists
+        if (metadata.module.dispose) {
+            metadata.module.dispose();
+        }
+        // Unregister all routes
+        const routeIds = this.routeTracker.get(moduleName) || [];
+        for (const routeId of routeIds) {
+            this.context.http.unregisterRoute(routeId);
+        }
+        // Remove from registry
+        this.registry.unregister(moduleName);
+        this.routeTracker.delete(moduleName);
+        this.context.logger?.log(`Module unloaded: ${moduleName}`);
+    }
+    async reload(modulePath) {
+        await this.load(modulePath);
+    }
+    list() {
+        return this.registry.list();
+    }
+    get(moduleName) {
+        return this.registry.get(moduleName);
+    }
+}
+exports.Kernel = Kernel;

package/dist/loader.d.ts

@@ -0,0 +1,6 @@
+import { RuntimeModule } from './types';
+export declare class ModuleLoader {
+    load(modulePath: string): Promise<RuntimeModule>;
+    private clearCache;
+    private isValidModule;
+}

package/dist/loader.js

@@ -0,0 +1,60 @@
+"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.ModuleLoader = void 0;
+const path = __importStar(require("path"));
+class ModuleLoader {
+    async load(modulePath) {
+        const resolvedPath = path.resolve(modulePath);
+        // Clear require cache for hot reload
+        this.clearCache(resolvedPath);
+        const moduleExport = require(resolvedPath);
+        const module = moduleExport.default || moduleExport;
+        if (!this.isValidModule(module)) {
+            throw new Error(`Invalid module at ${modulePath}: must implement RuntimeModule interface`);
+        }
+        return module;
+    }
+    clearCache(modulePath) {
+        delete require.cache[require.resolve(modulePath)];
+    }
+    isValidModule(obj) {
+        return (obj &&
+            typeof obj.name === 'string' &&
+            typeof obj.version === 'string' &&
+            typeof obj.register === 'function');
+    }
+}
+exports.ModuleLoader = ModuleLoader;

package/dist/module-registry.d.ts

@@ -0,0 +1,9 @@
+import { ModuleMetadata, RuntimeModule } from './types';
+export declare class ModuleRegistry {
+    private modules;
+    register(module: RuntimeModule, routeIds: string[]): void;
+    unregister(name: string): ModuleMetadata | undefined;
+    get(name: string): ModuleMetadata | undefined;
+    has(name: string): boolean;
+    list(): ModuleMetadata[];
+}

package/dist/module-registry.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleRegistry = void 0;
+class ModuleRegistry {
+    constructor() {
+        this.modules = new Map();
+    }
+    register(module, routeIds) {
+        this.modules.set(module.name, {
+            module,
+            version: module.version,
+            registeredRoutes: routeIds,
+            loadedAt: new Date()
+        });
+    }
+    unregister(name) {
+        const metadata = this.modules.get(name);
+        if (metadata) {
+            this.modules.delete(name);
+        }
+        return metadata;
+    }
+    get(name) {
+        return this.modules.get(name);
+    }
+    has(name) {
+        return this.modules.has(name);
+    }
+    list() {
+        return Array.from(this.modules.values());
+    }
+}
+exports.ModuleRegistry = ModuleRegistry;

package/dist/types.d.ts

@@ -0,0 +1,37 @@
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+export interface RouteDefinition {
+    id: string;
+    method: HttpMethod;
+    path: string;
+    handler: Function;
+}
+export interface HttpAdapter {
+    registerRoute(definition: RouteDefinition): void;
+    unregisterRoute(id: string): void;
+}
+export interface Logger {
+    log(message: string): void;
+    error(message: string): void;
+    warn(message: string): void;
+}
+export interface DependencyContainer {
+    get<T>(token: string): T;
+    register<T>(token: string, value: T): void;
+}
+export interface RuntimeContext {
+    http: HttpAdapter;
+    container?: DependencyContainer;
+    logger?: Logger;
+}
+export interface RuntimeModule {
+    name: string;
+    version: string;
+    register(context: RuntimeContext): void;
+    dispose?(): void;
+}
+export interface ModuleMetadata {
+    module: RuntimeModule;
+    version: string;
+    registeredRoutes: string[];
+    loadedAt: Date;
+}

package/dist/types.js

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

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@deployforme/core",
+  "version": "1.0.0",
+  "description": "Framework-agnostic runtime module management kernel",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "keywords": ["deploy4me", "hot-reload", "module-loading", "zero-downtime"],
+  "author": "Your Name <your.email@example.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yourusername/deploy4me.git",
+    "directory": "packages/core"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "pnpm build"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.3.0"
+  }
+}