architex-js 1.0.0

package/README.md

@@ -0,0 +1,111 @@
+# mixin-support
+
+**Library for JavaScript mixin support, provides an easy and useful interface for the implementation of this powerful concept.**
+
+## Description
+
+`mixin-support` is a library designed to simplify the implementation of mixins in JavaScript. By using this library, developers can easily create classes that inherit from multiple mixins, enhancing code reuse and modularity.
+
+## Installation
+
+To install the library, you can use npm:
+
+```bash
+npm install mixin-support
+```
+
+Or if you are using yarn:
+
+```bash
+yarn add mixin-support
+```
+
+
+## Usage
+
+The core of the library is the `MixinBuilder` class, which provides a static method `with` to create a class that combines multiple mixins.
+
+### Example
+
+Here's a basic example demonstrating how to use `mixin-support`:
+
+```js
+import { MixinBuilder } from 'mixin-support';
+
+// Define some mixins
+class MixinA {
+    constructor() {
+        this.name = 'MixinA';
+    }
+    greet() {
+        console.log(`Hello from ${this.name}`);
+    }
+}
+
+class MixinB {
+    constructor() {
+        this.type = 'MixinB';
+    }
+    describe() {
+        console.log(`This is ${this.type}`);
+    }
+}
+
+// Create a new class that combines the mixins
+class CombinedClass extends MixinBuilder.with(MixinA, MixinB) {
+    constructor() {
+        super();
+    }
+}
+
+const instance = new CombinedClass();
+instance.greet();      // Output: Hello from MixinA
+instance.describe();   // Output: This is MixinB
+
+```
+
+### Advanced Example
+
+For more advanced usage, you can include mixins that add static methods or properties to the final class:
+
+```js
+class StaticMixin {
+    static staticMethod() {
+        console.log('This is a static method');
+    }
+}
+
+// Create a new class that combines the mixins
+class AdvancedClass extends MixinBuilder.with(MixinA, MixinB, StaticMixin) {
+    constructor() {
+        super();
+    }
+}
+
+AdvancedClass.staticMethod();  // Output: This is a static method
+
+const advancedInstance = new AdvancedClass();
+advancedInstance.greet();      // Output: Hello from MixinA
+advancedInstance.describe();   // Output: This is MixinB
+
+```
+
+## API
+
+### `MixinBuilder`
+
+#### `static with(...mixins)`
+
+This static method takes any number of mixins and returns a new class that incorporates the properties and methods of each mixin. Mixins can be either classes or functions that return classes.
+
+* **Parameters** :
+* `...mixins`: The mixins to include in the final class.
+* **Returns** : The final class that includes all the mixins.
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## Contributing
+
+Contributions are welcome! Please open an issue or submit a pull request for any bugs or feature requests.

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "architex-js",
+  "version": "1.0.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"
+  },
+  "description": "Architectural Toolbox for JavaScript - Providing high-level building blocks for robust systems.",
+  "author": {
+    "name": "devjuanda",
+    "email": "penalozahernandezjuandavid03@gmail.com",
+    "url": "https://www.youtube.com/@codeend_01"
+  },
+  "license": "MIT",
+  "keywords": [
+    "architecture",
+    "toolbox",
+    "meta-framework",
+    "mixins",
+    "event-bus",
+    "microkernel",
+    "JavaScript",
+    "Node.js",
+    "Clean Code"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dev-juanda01/architex-js"
+  },
+  "homepage": "https://github.com/dev-juanda01/architex-js",
+  "type": "module",
+  "scripts": {
+    "test": "vitest run"
+  },
+  "devDependencies": {
+    "vitest": "^3.0.6"
+  }
+}

package/src/abc/ABC.js

@@ -0,0 +1,48 @@
+import {
+    InstantiatedAbstractClassException,
+    AbstractMethodNotImplementedException,
+} from "../exceptions/index.js";
+
+/**
+ * Provides functionality for defining abstract base classes.
+ */
+class ABC {
+    /**
+     * Creates an abstract base class that enforces method implementation in subclasses.
+     * @returns {Class} An abstract base class.
+     */
+    static abstract() {
+        return class AbstractBase {
+            constructor() {
+                // Prevent direct instantiation of the abstract class itself
+                if (new.target === AbstractBase || new.target.name === 'AbstractBase') {
+                    throw new InstantiatedAbstractClassException(
+                        `Cannot instantiate abstract class "${this.constructor.name}" directly.`
+                    );
+                }
+
+                // Get all methods defined in the immediate prototype of the class being instantiated
+                const implementedMethods = Object.getOwnPropertyNames(new.target.prototype)
+                    .filter(prop => typeof new.target.prototype[prop] === 'function' && prop !== 'constructor');
+
+                // Get the prototype of the abstract base (the one created by ABC.abstract)
+                const abstractPrototype = Object.getPrototypeOf(this);
+                const parentPrototype = Object.getPrototypeOf(abstractPrototype);
+
+                if (parentPrototype && parentPrototype !== Object.prototype) {
+                    Object.getOwnPropertyNames(parentPrototype)
+                        .filter(prop => prop !== 'constructor' && typeof parentPrototype[prop] === 'function')
+                        .forEach(methodName => {
+                            if (!implementedMethods.includes(methodName)) {
+                                throw new AbstractMethodNotImplementedException(
+                                    `Class "${new.target.name}" must implement abstract method: "${methodName}"`
+                                );
+                            }
+                        });
+                }
+            }
+        };
+    }
+}
+
+export { ABC };

package/src/abc/index.js

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

package/src/index.js

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

package/test/abstract-class.test.js

@@ -0,0 +1,19 @@
+import { describe, it, expect } from 'vitest';
+import { ABC } from "../src/index.js";
+
+describe('Legacy Abstract Class Support', () => {
+    it('should allow instantiation of a class that implements abstract methods', () => {
+        class A extends ABC.abstract() {
+            prepare() { }
+        }
+
+        class B extends A {
+            prepare() {
+                return "B prepared";
+            }
+        }
+
+        const b = new B();
+        expect(b.prepare()).toBe("B prepared");
+    });
+});

package/test/toolbox.test.js

@@ -0,0 +1,80 @@
+import { describe, it, expect } from 'vitest';
+import {
+    MixinBuilder,
+    ABC,
+    EventBus,
+    Microkernel,
+    AbstractMethodNotImplementedException,
+    InstantiatedAbstractClassException
+} from '../src/index.js';
+
+describe('Architecture Toolbox', () => {
+
+    describe('MixinBuilder & Abstract Classes', () => {
+        it('should throw InstantiatedAbstractClassException when instantiating abstract class directly', () => {
+            const AbstractBase = ABC.abstract();
+            expect(() => new AbstractBase()).toThrow(InstantiatedAbstractClassException);
+        });
+
+        it('should throw AbstractMethodNotImplementedException when subclass misses required methods', () => {
+            class Base extends ABC.abstract() {
+                mustImplement() { }
+            }
+
+            class Sub extends Base { }
+
+            expect(() => new Sub()).toThrow(AbstractMethodNotImplementedException);
+            expect(() => new Sub()).toThrow(/must implement abstract method: "mustImplement"/);
+        });
+
+        it('should work correctly when abstract methods are implemented', () => {
+            class Base extends ABC.abstract() {
+                greet() { }
+            }
+
+            class Sub extends Base {
+                greet() { return 'hello'; }
+            }
+
+            const instance = new Sub();
+            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);
+        });
+    });
+});