jcc-express-mvc 1.8.28 → 1.8.29

package/__tests__/ApplicationBuilder.test.js

@@ -5,36 +5,115 @@ const Application_1 = require("../lib/Application/Application");
 const ApplicationBuilder_1 = require("../lib/Application/ApplicationBuilder");
 (0, vitest_1.describe)("ApplicationBuilder", () => {
     let app;
+    let builder;
     (0, vitest_1.beforeEach)(() => {
         app = Application_1.Application.getInstance();
+        builder = new ApplicationBuilder_1.ApplicationBuilder(app);
     });
-    (0, vitest_1.it)("withConfig merges config without queue when queue is missing", () => {
-        const config = { custom: "value" };
-        const builder = new ApplicationBuilder_1.ApplicationBuilder(app);
-        (0, vitest_1.expect)(() => builder.withConfig(config)).not.toThrow();
-        (0, vitest_1.expect)(app.config).toMatchObject({ custom: "value" });
-        (0, vitest_1.expect)(app.has("Queue")).toBe(false);
-    });
-    (0, vitest_1.it)("withConfig stores queue config without registering Queue (QueueServiceProvider handles that)", () => {
-        const config = {
-            queue: {
+    // ── withConfig ──────────────────────────────────────────────────────────────
+    (0, vitest_1.describe)("withConfig", () => {
+        (0, vitest_1.it)("merges plain config into app.config", () => {
+            builder.withConfig({ custom: "value" });
+            (0, vitest_1.expect)(app.config).toMatchObject({ custom: "value" });
+        });
+        (0, vitest_1.it)("does not register Queue binding (that is QueueServiceProvider's job)", () => {
+            builder.withConfig({ queue: { default: "memory", connections: {} } });
+            (0, vitest_1.expect)(app.has("Queue")).toBe(false);
+        });
+        (0, vitest_1.it)("stores queue config on app.config", () => {
+            const queueCfg = {
                 default: "memory",
-                connections: {
-                    memory: { driver: "memory", queue: "default" },
-                },
-            },
-        };
-        const builder = new ApplicationBuilder_1.ApplicationBuilder(app);
-        builder.withConfig(config);
-        (0, vitest_1.expect)(app.config.queue).toMatchObject(config.queue);
-        (0, vitest_1.expect)(app.has("Queue")).toBe(false);
+                connections: { memory: { driver: "memory", queue: "default" } },
+            };
+            builder.withConfig({ queue: queueCfg });
+            (0, vitest_1.expect)(app.config.queue).toMatchObject(queueCfg);
+        });
+        (0, vitest_1.it)("merges multiple calls additively", () => {
+            builder.withConfig({ a: 1 });
+            builder.withConfig({ b: 2 });
+            (0, vitest_1.expect)(app.config).toMatchObject({ a: 1, b: 2 });
+        });
+        (0, vitest_1.it)("later call overwrites duplicate keys", () => {
+            builder.withConfig({ key: "first" });
+            builder.withConfig({ key: "second" });
+            (0, vitest_1.expect)(app.config.key).toBe("second");
+        });
+        (0, vitest_1.it)("returns the builder for chaining", () => {
+            const result = builder.withConfig({});
+            (0, vitest_1.expect)(result).toBe(builder);
+        });
+    });
+    // ── withRouting ─────────────────────────────────────────────────────────────
+    (0, vitest_1.describe)("withRouting", () => {
+        (0, vitest_1.it)("stores routes with rootPath prepended to name", () => {
+            builder.withRouting([{ name: "route/api", prefix: "/api" }]);
+            (0, vitest_1.expect)(app.configRoutes).toHaveLength(1);
+            (0, vitest_1.expect)(app.configRoutes[0].name).toContain("route/api");
+            (0, vitest_1.expect)(app.configRoutes[0].prefix).toBe("/api");
+        });
+        (0, vitest_1.it)("accepts multiple routes", () => {
+            builder.withRouting([
+                { name: "route/web", prefix: "/" },
+                { name: "route/api", prefix: "/api" },
+            ]);
+            (0, vitest_1.expect)(app.configRoutes).toHaveLength(2);
+        });
+        (0, vitest_1.it)("empty route list stores an empty array", () => {
+            builder.withRouting([]);
+            (0, vitest_1.expect)(app.configRoutes).toEqual([]);
+        });
+        (0, vitest_1.it)("returns the builder for chaining", () => {
+            const result = builder.withRouting([]);
+            (0, vitest_1.expect)(result).toBe(builder);
+        });
+    });
+    // ── withKernel ──────────────────────────────────────────────────────────────
+    (0, vitest_1.describe)("withKernel", () => {
+        (0, vitest_1.it)("binds the kernel class as HttpKernel", () => {
+            class FakeKernel {
+                constructor() {
+                    this.middlewares = [];
+                }
+            }
+            builder.withKernel(FakeKernel);
+            (0, vitest_1.expect)(app.has("HttpKernel")).toBe(true);
+        });
+        (0, vitest_1.it)("resolves to the provided kernel class", () => {
+            class FakeKernel {
+                constructor() {
+                    this.middlewares = [];
+                }
+            }
+            builder.withKernel(FakeKernel);
+            const resolved = app.resolve("HttpKernel");
+            (0, vitest_1.expect)(resolved).toBeInstanceOf(FakeKernel);
+        });
+        (0, vitest_1.it)("returns the builder for chaining", () => {
+            class FakeKernel {
+                constructor() {
+                    this.middlewares = [];
+                }
+            }
+            const result = builder.withKernel(FakeKernel);
+            (0, vitest_1.expect)(result).toBe(builder);
+        });
+    });
+    // ── withConsole ─────────────────────────────────────────────────────────────
+    (0, vitest_1.describe)("withConsole", () => {
+        (0, vitest_1.it)("binds ConsoleKernel into the container", () => {
+            builder.withConsole();
+            (0, vitest_1.expect)(app.has("ConsoleKernel")).toBe(true);
+        });
+        (0, vitest_1.it)("returns the builder for chaining", () => {
+            const result = builder.withConsole();
+            (0, vitest_1.expect)(result).toBe(builder);
+        });
     });
-    (0, vitest_1.it)("withRouting maps route config with rootPath", () => {
-        const builder = new ApplicationBuilder_1.ApplicationBuilder(app);
-        const routes = [{ name: "route/api", prefix: "/api" }];
-        builder.withRouting(routes);
-        (0, vitest_1.expect)(app.configRoutes).toHaveLength(1);
-        (0, vitest_1.expect)(app.configRoutes[0].name).toContain("route/api");
-        (0, vitest_1.expect)(app.configRoutes[0].prefix).toBe("/api");
+    // ── create ──────────────────────────────────────────────────────────────────
+    (0, vitest_1.describe)("create", () => {
+        (0, vitest_1.it)("returns the application instance", () => {
+            const result = builder.create();
+            (0, vitest_1.expect)(result).toBe(app);
+        });
     });
 });

package/__tests__/Container.test.js

@@ -2,70 +2,210 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const vitest_1 = require("vitest");
 const Application_1 = require("../lib/Application/Application");
-/**
- * Tests Container behavior via Application (extends ExpressApplication extends Container).
- */
 (0, vitest_1.describe)("Container", () => {
     let container;
     (0, vitest_1.beforeEach)(() => {
         container = Application_1.Application.getInstance();
     });
-    (0, vitest_1.it)("binds and resolves a value via factory", () => {
-        container.bind("Foo", () => "bar");
-        (0, vitest_1.expect)(container.resolve("Foo")).toBe("bar");
+    // ── bind / resolve ──────────────────────────────────────────────────────────
+    (0, vitest_1.describe)("bind / resolve", () => {
+        (0, vitest_1.it)("binds a factory and resolves its return value", () => {
+            container.bind("Foo", () => "bar");
+            (0, vitest_1.expect)(container.resolve("Foo")).toBe("bar");
+        });
+        (0, vitest_1.it)("shared bind returns same instance on repeated resolves", () => {
+            class Service {
+            }
+            container.bind("SharedSvc", Service, true);
+            const a = container.resolve("SharedSvc");
+            const b = container.resolve("SharedSvc");
+            (0, vitest_1.expect)(a).toBeInstanceOf(Service);
+            (0, vitest_1.expect)(a).toBe(b);
+        });
+        (0, vitest_1.it)("non-shared bind returns a new instance on each resolve", () => {
+            class Disposable {
+            }
+            container.bind("Disposable", Disposable, false);
+            const a = container.resolve("Disposable");
+            const b = container.resolve("Disposable");
+            (0, vitest_1.expect)(a).not.toBe(b);
+        });
+        (0, vitest_1.it)("resolve throws for unregistered abstract", () => {
+            (0, vitest_1.expect)(() => container.resolve("__never_registered__")).toThrow(/No binding registered/);
+        });
+        (0, vitest_1.it)("binds a factory function and resolves its return value each call", () => {
+            let n = 0;
+            container.bind("Counter", () => ++n);
+            (0, vitest_1.expect)(container.resolve("Counter")).toBe(1);
+            (0, vitest_1.expect)(container.resolve("Counter")).toBe(2);
+        });
     });
-    (0, vitest_1.it)("binds a class and resolves instance", () => {
-        class Service {
-        }
-        container.bind("Service", Service, true);
-        const a = container.resolve("Service");
-        const b = container.resolve("Service");
-        (0, vitest_1.expect)(a).toBeInstanceOf(Service);
-        (0, vitest_1.expect)(a).toBe(b); // shared
+    // ── singleton ───────────────────────────────────────────────────────────────
+    (0, vitest_1.describe)("singleton", () => {
+        (0, vitest_1.it)("returns same instance on every resolve", () => {
+            class Singleton {
+            }
+            container.singleton("MySingleton", Singleton);
+            const a = container.resolve("MySingleton");
+            const b = container.resolve("MySingleton");
+            (0, vitest_1.expect)(a).toBe(b);
+        });
+        (0, vitest_1.it)("does not re-register if already bound", () => {
+            class First {
+            }
+            class Second {
+            }
+            container.singleton("OnceOnly", First);
+            container.singleton("OnceOnly", Second); // should be ignored
+            const inst = container.resolve("OnceOnly");
+            (0, vitest_1.expect)(inst).toBeInstanceOf(First);
+        });
     });
-    (0, vitest_1.it)("singleton returns same instance", () => {
-        class Singleton {
-        }
-        container.singleton("Singleton", Singleton);
-        const a = container.resolve("Singleton");
-        const b = container.resolve("Singleton");
-        (0, vitest_1.expect)(a).toBe(b);
+    // ── instance ────────────────────────────────────────────────────────────────
+    (0, vitest_1.describe)("instance", () => {
+        (0, vitest_1.it)("stores a concrete object and returns the same reference", () => {
+            const obj = { id: 99 };
+            container.instance("ConcreteObj", obj);
+            (0, vitest_1.expect)(container.resolve("ConcreteObj")).toBe(obj);
+        });
+        (0, vitest_1.it)("instance also populates aliased key if alias was registered first", () => {
+            const obj = { val: "shared" };
+            container.alias("AliasTarget", "AliasKey");
+            container.instance("AliasTarget", obj);
+            (0, vitest_1.expect)(container.resolve("AliasKey")).toBe(obj);
+        });
     });
-    (0, vitest_1.it)("instance sets concrete instance", () => {
-        const obj = { id: 1 };
-        container.instance("Obj", obj);
-        (0, vitest_1.expect)(container.resolve("Obj")).toBe(obj);
+    // ── alias ───────────────────────────────────────────────────────────────────
+    (0, vitest_1.describe)("alias", () => {
+        (0, vitest_1.it)("resolves via alias to original binding", () => {
+            container.bind("OrigSvc", () => "from-orig");
+            container.alias("OrigSvc", "Aliased");
+            (0, vitest_1.expect)(container.resolve("Aliased")).toBe("from-orig");
+        });
     });
-    (0, vitest_1.it)("alias resolves to original binding", () => {
-        container.bind("Original", () => "value");
-        container.alias("Original", "Alias");
-        (0, vitest_1.expect)(container.resolve("Alias")).toBe("value");
+    // ── has ─────────────────────────────────────────────────────────────────────
+    (0, vitest_1.describe)("has", () => {
+        (0, vitest_1.it)("returns true for a bound abstract", () => {
+            container.bind("BoundKey", () => null);
+            (0, vitest_1.expect)(container.has("BoundKey")).toBe(true);
+        });
+        (0, vitest_1.it)("returns true for an instance", () => {
+            container.instance("InstKey", {});
+            (0, vitest_1.expect)(container.has("InstKey")).toBe(true);
+        });
+        (0, vitest_1.it)("returns true for an alias", () => {
+            container.bind("RealKey", () => null);
+            container.alias("RealKey", "AliasForHas");
+            (0, vitest_1.expect)(container.has("AliasForHas")).toBe(true);
+        });
+        (0, vitest_1.it)("returns false for an unknown key", () => {
+            (0, vitest_1.expect)(container.has("__not_there__")).toBe(false);
+        });
     });
-    (0, vitest_1.it)("has returns true for registered bindings", () => {
-        container.bind("X", "y");
-        (0, vitest_1.expect)(container.has("X")).toBe(true);
-        (0, vitest_1.expect)(container.has("Unknown")).toBe(false);
+    // ── forget ──────────────────────────────────────────────────────────────────
+    (0, vitest_1.describe)("forget", () => {
+        (0, vitest_1.it)("removes a singleton instance so the next resolve creates a fresh one", () => {
+            class Temp {
+            }
+            container.singleton("TempSvc", Temp);
+            const a = container.resolve("TempSvc");
+            container.forget("TempSvc");
+            const b = container.resolve("TempSvc");
+            (0, vitest_1.expect)(a).not.toBe(b);
+        });
+        (0, vitest_1.it)("removes the aliased instance as well", () => {
+            class TZ {
+            }
+            container.singleton("TZBase", TZ);
+            container.alias("TZBase", "TZAlias");
+            container.resolve("TZBase"); // cache it
+            container.forget("TZBase"); // should also clear aliased cache
+            // after forget the binding is still there, so resolve works but returns new instance
+            (0, vitest_1.expect)(() => container.resolve("TZBase")).not.toThrow();
+        });
     });
-    (0, vitest_1.it)("forget removes instance", () => {
-        class Temp {
-        }
-        container.singleton("Temp", Temp);
-        const a = container.resolve("Temp");
-        container.forget("Temp");
-        const b = container.resolve("Temp");
-        (0, vitest_1.expect)(a).not.toBe(b);
+    // ── forgetMany ──────────────────────────────────────────────────────────────
+    (0, vitest_1.describe)("forgetMany", () => {
+        (0, vitest_1.it)("removes all listed instances", () => {
+            class A {
+            }
+            class B {
+            }
+            container.singleton("AA", A);
+            container.singleton("BB", B);
+            const a1 = container.resolve("AA");
+            const b1 = container.resolve("BB");
+            container.forgetMany(["AA", "BB"]);
+            const a2 = container.resolve("AA");
+            const b2 = container.resolve("BB");
+            (0, vitest_1.expect)(a1).not.toBe(a2);
+            (0, vitest_1.expect)(b1).not.toBe(b2);
+        });
+        (0, vitest_1.it)("is a no-op for unknown keys", () => {
+            (0, vitest_1.expect)(() => container.forgetMany(["__x__", "__y__"])).not.toThrow();
+        });
     });
-    (0, vitest_1.it)("make instantiates class with auto-binding", () => {
-        class MyService {
-            constructor() {
-                this.name = "test";
+    // ── make ────────────────────────────────────────────────────────────────────
+    (0, vitest_1.describe)("make", () => {
+        (0, vitest_1.it)("instantiates a class without prior binding", () => {
+            class Widget {
+                constructor() {
+                    this.name = "widget";
+                }
+            }
+            const inst = container.make(Widget);
+            (0, vitest_1.expect)(inst).toBeInstanceOf(Widget);
+            (0, vitest_1.expect)(inst?.name).toBe("widget");
+        });
+        (0, vitest_1.it)("passes explicit constructor arguments", () => {
+            class Greeter {
+                constructor(greeting) {
+                    this.greeting = greeting;
+                }
             }
-        }
-        const instance = container.make(MyService);
-        (0, vitest_1.expect)(instance).toBeInstanceOf(MyService);
-        (0, vitest_1.expect)(instance?.name).toBe("test");
+            const inst = container.make(Greeter, ["hello"]);
+            (0, vitest_1.expect)(inst?.greeting).toBe("hello");
+        });
     });
-    (0, vitest_1.it)("resolve throws for unregistered binding", () => {
-        (0, vitest_1.expect)(() => container.resolve("NonExistent")).toThrow(/No binding registered/);
+    // ── build ───────────────────────────────────────────────────────────────────
+    (0, vitest_1.describe)("build", () => {
+        (0, vitest_1.it)("builds a class with no dependencies", () => {
+            class Plain {
+            }
+            const inst = container.build(Plain);
+            (0, vitest_1.expect)(inst).toBeInstanceOf(Plain);
+        });
+        (0, vitest_1.it)("builds a class passing explicit params", () => {
+            class Parameterised {
+                constructor(x) {
+                    this.x = x;
+                }
+            }
+            const inst = container.build(Parameterised, [42]);
+            (0, vitest_1.expect)(inst.x).toBe(42);
+        });
+        (0, vitest_1.it)("calls a factory function if given one", () => {
+            const factory = () => ({ built: true });
+            const result = container.build(factory);
+            (0, vitest_1.expect)(result.built).toBe(true);
+        });
+    });
+    // ── callMethod ──────────────────────────────────────────────────────────────
+    (0, vitest_1.describe)("callMethod", () => {
+        (0, vitest_1.it)("calls a plain method (no @Inject metadata) with provided args", () => {
+            class Calculator {
+                add(a, b) {
+                    return a + b;
+                }
+            }
+            const calc = new Calculator();
+            const result = container.callMethod(calc, "add", 3, 4);
+            (0, vitest_1.expect)(result).toBe(7);
+        });
+        (0, vitest_1.it)("throws an AppError when the method does not exist", () => {
+            class Empty {
+            }
+            (0, vitest_1.expect)(() => container.callMethod(new Empty(), "nonExistent")).toThrow();
+        });
     });
 });

package/__tests__/Job.test.js

@@ -188,3 +188,73 @@ class NestedFolderJob extends Job_1.Job {
         spy.mockRestore();
     });
 });
+// ── Queue additional methods ──────────────────────────────────────────────────
+(0, vitest_1.describe)("Queue additional methods", () => {
+    let queue;
+    let app;
+    let originalApp;
+    (0, vitest_1.beforeEach)(() => {
+        app = Application_1.Application.getInstance();
+        originalApp = globalThis.app;
+        globalThis.app = app;
+        queue = new Queue_1.Queue({ driver: "memory", queue: "default" });
+        app.instance("Queue", queue);
+    });
+    (0, vitest_1.afterEach)(() => {
+        globalThis.app = originalApp;
+    });
+    (0, vitest_1.describe)("registerJob", () => {
+        (0, vitest_1.it)("registers a job class so processNext can resolve it", async () => {
+            queue.registerJob("TestJob", TestJob);
+            const job = new TestJob({ value: "registered" });
+            await queue.push(job);
+            const result = await queue.processNext();
+            (0, vitest_1.expect)(result).toBe(true);
+        });
+    });
+    (0, vitest_1.describe)("getQueues", () => {
+        (0, vitest_1.it)("returns an array (empty when no jobs are queued)", async () => {
+            const queues = await queue.getQueues();
+            (0, vitest_1.expect)(Array.isArray(queues)).toBe(true);
+        });
+        (0, vitest_1.it)("returns records after a job is pushed", async () => {
+            const job = new TestJob({ value: "q-test" });
+            await queue.push(job);
+            const queues = await queue.getQueues();
+            (0, vitest_1.expect)(queues.length).toBeGreaterThan(0);
+        });
+    });
+    (0, vitest_1.describe)("findQueueById", () => {
+        (0, vitest_1.it)("returns the job record for a known id", async () => {
+            const job = new TestJob({ value: "find-me" });
+            const id = await queue.push(job);
+            const record = await queue.findQueueById(id);
+            (0, vitest_1.expect)(record).toBeDefined();
+        });
+        (0, vitest_1.it)("returns undefined/null for an unknown id", async () => {
+            const record = await queue.findQueueById("non-existent-id");
+            (0, vitest_1.expect)(record == null).toBe(true);
+        });
+    });
+    (0, vitest_1.describe)("findQueueBy", () => {
+        (0, vitest_1.it)("finds jobs by queue name", async () => {
+            const job = new TestJob({ value: "by-queue" });
+            await queue.push(job);
+            const results = await queue.findQueueBy("queue", "default");
+            (0, vitest_1.expect)(Array.isArray(results)).toBe(true);
+            (0, vitest_1.expect)(results.length).toBeGreaterThan(0);
+        });
+    });
+    (0, vitest_1.describe)("deleteJob", () => {
+        (0, vitest_1.it)("removes a job so it is no longer found", async () => {
+            const job = new TestJob({ value: "delete-me" });
+            const id = await queue.push(job);
+            await queue.deleteJob(id);
+            const record = await queue.findQueueById(id);
+            (0, vitest_1.expect)(record == null).toBe(true);
+        });
+        (0, vitest_1.it)("does not throw when deleting an unknown id", async () => {
+            await (0, vitest_1.expect)(queue.deleteJob("ghost-id")).resolves.not.toThrow();
+        });
+    });
+});