architex-js 1.2.0 → 1.4.0

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "architex-js",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "main": "src/index.js",
   "exports": {
     ".": "./src/index.js",
     "./abc": "./src/abc/index.js",
     "./mixins": "./src/mixins/index.js",
     "./microkernel": "./src/microkernel/index.js",
-    "./exceptions": "./src/exceptions/index.js"
+    "./exceptions": "./src/exceptions/index.js",
+    "./pipeline": "./src/pipeline/index.js"
   },
   "description": "Architectural Toolbox for JavaScript - Providing high-level building blocks for robust systems.",
   "author": {

package/src/index.js

@@ -1,4 +1,5 @@
 export * from "./abc/index.js";
 export * from "./mixins/index.js";
 export * from "./microkernel/index.js";
-export * from "./exceptions/index.js";
+export * from "./exceptions/index.js";
+export * from "./pipeline/index.js";

package/src/microkernel/Microkernel.js

@@ -0,0 +1,60 @@
+import path from "node:path";
+import fs from "node:fs";
+
+/**
+ * Microkernel class to manage plugins and core functionality.
+ */
+class Microkernel {
+    constructor() {
+        this.plugins = new Map();
+        this.registry = {};
+    }
+
+    /**
+     * Boot the kernel and load plugins from the specified directory.
+     * @param {string} pluginsPath - The path to the plugins directory.
+     */
+    async boot(pluginsPath) {
+        const dir = path.resolve(pluginsPath);
+        const files = fs.readdirSync(dir);
+
+        for (const file of files) {
+            if (file.endsWith('.js')) {
+                const PluginClass = require(path.join(dir, file));
+                const instance = new PluginClass();
+
+                // VALIDATION: Is it a valid plugin from our suite?
+                if (!(instance instanceof BasePlugin)) {
+                    console.error(`[Kernel] Ignored: ${file} does not extend BasePlugin.`);
+                    continue;
+                }
+
+                const name = instance.name || file.replace('.js', '');
+                this.plugins.set(name, instance);
+
+                // Execute the mandatory contract
+                await instance.setup(this);
+            }
+        }
+    }
+
+    /**
+     * Allows a plugin to offer a functionality to the rest of the system
+     * @param {string} key 
+     * @param {any} service 
+     */
+    provideService(key, service) {
+        this.registry[key] = service;
+    }
+
+    /**
+     * Allows a plugin to consume a functionality of another
+     * @param {string} key 
+     * @returns 
+     */
+    getService(key) {
+        return this.registry[key];
+    }
+}
+
+export { Microkernel };

package/src/microkernel/index.js

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

package/src/pipeline/Pipeline.js

@@ -0,0 +1,71 @@
+/**
+ * Represents a single step in a pipeline.
+ * @template T
+ * @callback PipelineStep
+ * @param {T} payload - The data passing through the pipeline.
+ * @returns {T | Promise<T>} The transformed data.
+ */
+
+/**
+ * A sequential data-processing pipeline (Chain of Responsibility).
+ * Each step receives the output of the previous step.
+ *
+ * @template T
+ *
+ * @example
+ * const result = await Pipeline.create()
+ *   .pipe(validate)
+ *   .pipe(transform)
+ *   .pipe(save)
+ *   .run(payload);
+ */
+class Pipeline {
+    constructor() {
+        /** @type {Array<PipelineStep>} */
+        this._steps = [];
+    }
+
+    /**
+     * Creates a new empty Pipeline instance.
+     * @returns {Pipeline}
+     */
+    static create() {
+        return new Pipeline();
+    }
+
+    /**
+     * Adds a processing step to the pipeline.
+     * @param {PipelineStep} step - A function (sync or async) that receives and returns the payload.
+     * @returns {Pipeline} The same pipeline instance (fluent API).
+     */
+    pipe(step) {
+        if (typeof step !== 'function') {
+            throw new TypeError(`Pipeline.pipe() expects a function, got: ${typeof step}`);
+        }
+        this._steps.push(step);
+        return this;
+    }
+
+    /**
+     * Executes all pipeline steps sequentially.
+     * @param {T} initialPayload - The initial data to pass through the pipeline.
+     * @returns {Promise<T>} The final transformed payload.
+     */
+    async run(initialPayload) {
+        let payload = initialPayload;
+        for (const step of this._steps) {
+            payload = await step(payload);
+        }
+        return payload;
+    }
+
+    /**
+     * Returns the number of steps registered in the pipeline.
+     * @returns {number}
+     */
+    get size() {
+        return this._steps.length;
+    }
+}
+
+export { Pipeline };

package/src/pipeline/index.js

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

package/test/pipeline.test.js

@@ -0,0 +1,43 @@
+import { describe, it, expect } from 'vitest';
+import { Pipeline } from '../src/pipeline/index.js';
+
+describe('Pipeline', () => {
+    it('should run steps sequentially and return the final result', async () => {
+        const result = await Pipeline.create()
+            .pipe(x => x + 1)
+            .pipe(x => x * 2)
+            .pipe(x => x - 3)
+            .run(5);
+
+        // (5 + 1) * 2 - 3 = 9
+        expect(result).toBe(9);
+    });
+
+    it('should support async steps', async () => {
+        const result = await Pipeline.create()
+            .pipe(async x => x + 10)
+            .pipe(async x => x * 2)
+            .run(5);
+
+        // (5 + 10) * 2 = 30
+        expect(result).toBe(30);
+    });
+
+    it('should report the correct number of steps', () => {
+        const pipeline = Pipeline.create()
+            .pipe(x => x)
+            .pipe(x => x)
+            .pipe(x => x);
+
+        expect(pipeline.size).toBe(3);
+    });
+
+    it('should throw if a non-function is passed to pipe()', () => {
+        expect(() => Pipeline.create().pipe(42)).toThrow(TypeError);
+    });
+
+    it('should return the initial payload if no steps are added', async () => {
+        const result = await Pipeline.create().run({ id: 1 });
+        expect(result).toEqual({ id: 1 });
+    });
+});

package/test/toolbox.test.js

@@ -2,8 +2,6 @@ import { describe, it, expect } from 'vitest';
 import {
     MixinBuilder,
     ABC,
-    EventBus,
-    Microkernel,
     AbstractMethodNotImplementedException,
     InstantiatedAbstractClassException
 } from '../src/index.js';
@@ -40,41 +38,4 @@ describe('Architecture Toolbox', () => {
             expect(instance.greet()).toBe('hello');
         });
     });
-
-    describe('EventBus', () => {
-        it('should emit and receive events', () => {
-            const bus = new EventBus();
-            let received = null;
-            bus.on('test', (data) => { received = data; });
-            bus.emit('test', 'payload');
-            expect(received).toBe('payload');
-        });
-
-        it('should handle "once" subscriptions', () => {
-            const bus = new EventBus();
-            let count = 0;
-            bus.once('test', () => { count++; });
-            bus.emit('test');
-            bus.emit('test');
-            expect(count).toBe(1);
-        });
-    });
-
-    describe('Microkernel', () => {
-        it('should register and start plugins', async () => {
-            const kernel = new Microkernel();
-            let started = false;
-
-            const plugin = {
-                install: (k) => k.set('service', { ok: true }),
-                start: async () => { started = true; }
-            };
-
-            kernel.register('test-plugin', plugin);
-            expect(kernel.get('service').ok).toBe(true);
-
-            await kernel.start();
-            expect(started).toBe(true);
-        });
-    });
 });