@raubjo/architect-core 0.1.0

package/tests/cache.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, test } from "bun:test";
+import ConfigRepository from "../src/config/repository";
+import CacheManager from "../src/cache/manager";
+
+describe("CacheManager", () => {
+  test("uses cache.default and configured stores", async () => {
+    const manager = CacheManager.fromConfig(
+      new ConfigRepository({
+        cache: {
+          default: "persistent",
+          stores: {
+            persistent: { driver: "memory" },
+            fast: { driver: "memory" },
+          },
+        },
+      }),
+    );
+
+    await manager.set("key", "value");
+    expect(await manager.get("key")).toBe("value");
+    expect(await manager.has("key")).toBe(true);
+    expect(await manager.keys()).toEqual(["key"]);
+    await manager.delete("key");
+    expect(await manager.get("key")).toBeNull();
+    await manager.set("other", 1);
+    await manager.clear();
+    expect(await manager.keys()).toEqual([]);
+
+    manager.use("fast");
+    await manager.set("fast-key", 123);
+    expect(await manager.get("fast-key")).toBe(123);
+  });
+
+  test("falls back to default stores and memory default", async () => {
+    const manager = CacheManager.fromConfig(new ConfigRepository({}));
+    await manager.set("a", 1);
+    expect(await manager.get("a")).toBe(1);
+    expect(manager.store("memory")).toBeTruthy();
+  });
+
+  test("resolves missing driver/store behavior", () => {
+    const manager = CacheManager.fromConfig(
+      new ConfigRepository({
+        cache: {
+          default: "missing",
+          stores: {
+            only: { driver: "unknown" },
+          },
+        },
+      }),
+    );
+
+    expect(manager.store()).toBeTruthy();
+    expect(() => manager.store("nope")).toThrow("Cache store [nope] is not defined.");
+  });
+
+  test("handles non-object cache.stores by using defaults", () => {
+    const manager = CacheManager.fromConfig(
+      new ConfigRepository({
+        cache: {
+          stores: "bad-value",
+        },
+      }),
+    );
+
+    expect(manager.store("memory")).toBeTruthy();
+  });
+});

package/tests/config-clone.test.ts

@@ -0,0 +1,31 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { cloneConfigItems } from "../src/config/clone";
+
+describe("cloneConfigItems", () => {
+  afterEach(() => {
+    (globalThis as { structuredClone?: typeof structuredClone }).structuredClone =
+      originalStructuredClone;
+  });
+
+  const originalStructuredClone = globalThis.structuredClone;
+
+  test("uses structuredClone when available", () => {
+    const input = { app: { name: "IOC" } };
+
+    const cloned = cloneConfigItems(input);
+    expect(cloned).toEqual(input);
+    expect(cloned).not.toBe(input);
+    expect(cloned.app).not.toBe(input.app);
+  });
+
+  test("falls back to JSON clone when structuredClone is unavailable", () => {
+    (globalThis as { structuredClone?: typeof structuredClone }).structuredClone = undefined;
+
+    const input = { app: { name: "IOC" } };
+    const cloned = cloneConfigItems(input);
+
+    expect(cloned).toEqual(input);
+    expect(cloned).not.toBe(input);
+    expect(cloned.app).not.toBe(input.app);
+  });
+});

package/tests/config-env.test.ts

@@ -0,0 +1,88 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { __envTesting, env, registerGlobalEnv } from "../src/config/env";
+
+describe("env helper", () => {
+  const originalProcess = (globalThis as { process?: unknown }).process;
+  const originalGlobalEnv = (globalThis as { env?: unknown }).env;
+  const originalImportMetaEnv = (
+    globalThis as { __iocImportMetaEnvForTests?: unknown }
+  ).__iocImportMetaEnvForTests;
+
+  afterEach(() => {
+    (globalThis as { process?: unknown }).process = originalProcess;
+    (globalThis as { env?: unknown }).env = originalGlobalEnv;
+    (
+      globalThis as { __iocImportMetaEnvForTests?: unknown }
+    ).__iocImportMetaEnvForTests = originalImportMetaEnv;
+  });
+
+  test("returns default when key does not exist", () => {
+    (globalThis as { process?: { env: Record<string, unknown> } }).process = {
+      env: {},
+    };
+
+    expect(env("MISSING", "fallback")).toBe("fallback");
+  });
+
+  test("reads values from process env with laravel-like casts", () => {
+    (
+      globalThis as { __iocImportMetaEnvForTests?: unknown }
+    ).__iocImportMetaEnvForTests = undefined;
+    (globalThis as { process?: { env: Record<string, unknown> } }).process = {
+      env: {
+        BOOL_TRUE: "true",
+        BOOL_FALSE: "(false)",
+        NULL_VAL: "null",
+        EMPTY_VAL: "(empty)",
+        RAW: "abc",
+        NUM: 123,
+      },
+    };
+
+    expect(env("BOOL_TRUE")).toBe(true);
+    expect(env("BOOL_FALSE")).toBe(false);
+    expect(env("NULL_VAL", "x")).toBeNull();
+    expect(env("EMPTY_VAL", "x")).toBe("");
+    expect(env("RAW")).toBe("abc");
+    expect(env("NUM")).toBe(123);
+  });
+
+  test("prefers import-meta env when key exists there", () => {
+    (
+      globalThis as { __iocImportMetaEnvForTests?: Record<string, unknown> }
+    ).__iocImportMetaEnvForTests = {
+      CACHE_STORE: "(true)",
+    };
+    (globalThis as { process?: { env: Record<string, unknown> } }).process = {
+      env: {
+        CACHE_STORE: "false",
+      },
+    };
+
+    expect(env("CACHE_STORE")).toBe(true);
+  });
+
+  test("registers global env function without overriding existing one", () => {
+    (globalThis as { env?: unknown }).env = undefined;
+    registerGlobalEnv();
+    expect(typeof (globalThis as { env?: unknown }).env).toBe("function");
+
+    const custom = () => "custom";
+    (globalThis as { env?: unknown }).env = custom;
+    registerGlobalEnv();
+    expect((globalThis as { env?: unknown }).env).toBe(custom);
+  });
+
+  test("exposes env helper internals", () => {
+    expect(__envTesting.normalizeEnvValue("(true)")).toBe(true);
+    expect(typeof __envTesting.resolveImportMetaEnv()).toBe("object");
+
+    (globalThis as { process?: unknown }).process = undefined;
+    expect(__envTesting.resolveProcessEnv()).toEqual({});
+
+    (globalThis as { process?: { env: Record<string, unknown> } }).process = {
+      env: { APP_ENV: "local" },
+    };
+    expect(__envTesting.resolveProcessEnv()).toEqual({ APP_ENV: "local" });
+  });
+});

package/tests/config-facade.test.ts

@@ -0,0 +1,96 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { Container } from "inversify";
+import ConfigRepository from "../src/config/repository";
+import { Application } from "../src/foundation/application";
+import Config from "../src/support/facades/config";
+import Facade from "../src/support/facades/facade";
+import ConfigServiceProvider from "../src/support/providers/config-service-provider";
+
+describe("Config facade", () => {
+  afterEach(() => {
+    Facade.clearResolvedInstances();
+    (Application as unknown as { container: Container | null }).container = null;
+  });
+
+  test("resolves repository from the container using the config accessor", () => {
+    const container = new Container();
+    new ConfigServiceProvider({
+      app: {
+        name: "From Provider",
+      },
+    }).register({ container });
+
+    (Application as unknown as { container: Container | null }).container = container;
+
+    expect(Config.get("app.name")).toBe("From Provider");
+    expect(container.get(ConfigRepository).get("app.name")).toBe("From Provider");
+  });
+
+  test("uses expected facade accessor name", () => {
+    expect((Config as unknown as { getFacadeAccessor: () => string }).getFacadeAccessor()).toBe(
+      "config",
+    );
+  });
+
+  test("facade class constructor is defined", () => {
+    const instance = new (Config as unknown as { new (): object })();
+    expect(instance).toBeTruthy();
+  });
+
+  test("uses facade cache until resolved instances are cleared", () => {
+    const container = new Container();
+    container
+      .bind("config")
+      .toConstantValue(new ConfigRepository({ app: { name: "First" } }));
+    container
+      .bind(ConfigRepository)
+      .toConstantValue(new ConfigRepository({ app: { name: "First" } }));
+    (Application as unknown as { container: Container | null }).container = container;
+
+    expect(Config.get("app.name")).toBe("First");
+
+    // Rebind underlying container value; facade should still return cached first instance.
+    container.unbind("config");
+    container.bind("config").toConstantValue(new ConfigRepository({ app: { name: "Second" } }));
+    expect(Config.get("app.name")).toBe("First");
+
+    Facade.clearResolvedInstances();
+    expect(Config.get("app.name")).toBe("Second");
+  });
+
+  test("delegates full method surface to repository", () => {
+    const container = new Container();
+    const repository = new ConfigRepository({
+      app: {
+        name: "IOC",
+        retries: 3,
+        ratio: 1.5,
+        enabled: true,
+        tags: ["base"],
+      },
+    });
+    container.bind("config").toConstantValue(repository);
+    container.bind(ConfigRepository).toConstantValue(repository);
+    (Application as unknown as { container: Container | null }).container = container;
+
+    expect(Config.has("app.name")).toBe(true);
+    expect(Config.getMany(["app.name"])).toEqual({ "app.name": "IOC" });
+    expect(Config.string("app.name")).toBe("IOC");
+    expect(Config.integer("app.retries")).toBe(3);
+    expect(Config.float("app.ratio")).toBe(1.5);
+    expect(Config.boolean("app.enabled")).toBe(true);
+    expect(Config.array("app.tags")).toEqual(["base"]);
+
+    Config.set("app.name", "Changed");
+    Config.prepend("app.tags", "first");
+    Config.push("app.tags", "last");
+
+    expect(Config.get("app.name")).toBe("Changed");
+    expect(Config.array("app.tags")).toEqual(["first", "base", "last"]);
+    expect(Config.all()).toMatchObject({
+      app: {
+        name: "Changed",
+      },
+    });
+  });
+});

package/tests/config-repository.test.ts

@@ -0,0 +1,124 @@
+import { describe, expect, test } from "bun:test";
+import ConfigRepository from "../src/config/repository";
+
+describe("ConfigRepository", () => {
+  test("gets nested values by dot key", () => {
+    const repository = new ConfigRepository({
+      app: {
+        name: "IOC Application",
+        timezone: "UTC",
+      },
+    });
+
+    expect(repository.get("app.name")).toBe("IOC Application");
+    expect(repository.get("app.timezone")).toBe("UTC");
+  });
+
+  test("supports defaults and lazy default callbacks", () => {
+    const repository = new ConfigRepository({});
+
+    expect(repository.get("app.locale", "en")).toBe("en");
+    expect(repository.get("app.name", () => "fallback")).toBe("fallback");
+  });
+
+  test("supports set, prepend, and push", () => {
+    const repository = new ConfigRepository({
+      app: {
+        middlewares: ["auth"],
+      },
+    });
+
+    repository.prepend("app.middlewares", "throttle");
+    repository.push("app.middlewares", "verified");
+    repository.set("app.name", "IOC");
+
+    expect(repository.get("app.name")).toBe("IOC");
+    expect(repository.array("app.middlewares")).toEqual([
+      "throttle",
+      "auth",
+      "verified",
+    ]);
+  });
+
+  test("supports getMany with list and defaults map", () => {
+    const repository = new ConfigRepository({
+      app: { name: "IOC Application" },
+    });
+
+    expect(repository.getMany(["app.name", "app.locale"])).toEqual({
+      "app.name": "IOC Application",
+      "app.locale": null,
+    });
+
+    expect(
+      repository.getMany({
+        "app.name": "fallback",
+        "app.locale": "en",
+      }),
+    ).toEqual({
+      "app.name": "IOC Application",
+      "app.locale": "en",
+    });
+  });
+
+  test("typed accessors return expected values", () => {
+    const repository = new ConfigRepository({
+      app: {
+        name: "IOC",
+        retries: 3,
+        ratio: 0.75,
+        enabled: true,
+        tags: ["alpha"],
+      },
+    });
+
+    expect(repository.string("app.name")).toBe("IOC");
+    expect(repository.integer("app.retries")).toBe(3);
+    expect(repository.float("app.ratio")).toBe(0.75);
+    expect(repository.boolean("app.enabled")).toBe(true);
+    expect(repository.array("app.tags")).toEqual(["alpha"]);
+  });
+
+  test("typed accessors throw when type does not match", () => {
+    const repository = new ConfigRepository({
+      app: {
+        name: 123,
+        retries: "3",
+        ratio: "0.75",
+        enabled: "yes",
+        tags: "nope",
+      },
+    });
+
+    expect(() => repository.string("app.name")).toThrow(
+      "Configuration value [app.name] is not a string.",
+    );
+    expect(() => repository.integer("app.retries")).toThrow(
+      "Configuration value [app.retries] is not an integer.",
+    );
+    expect(() => repository.float("app.ratio")).toThrow(
+      "Configuration value [app.ratio] is not a float.",
+    );
+    expect(() => repository.boolean("app.enabled")).toThrow(
+      "Configuration value [app.enabled] is not a boolean.",
+    );
+    expect(() => repository.array("app.tags")).toThrow(
+      "Configuration value [app.tags] is not an array.",
+    );
+  });
+
+  test("supports offset-style helpers", () => {
+    const repository = new ConfigRepository({
+      app: { name: "IOC Application" },
+    });
+
+    expect(repository.offsetExists("app.name")).toBe(true);
+    expect(repository.offsetGet("app.name")).toBe("IOC Application");
+
+    repository.offsetSet("app.name", "Changed");
+    expect(repository.offsetGet("app.name")).toBe("Changed");
+
+    repository.offsetUnset("app.name");
+    expect(repository.offsetExists("app.name")).toBe(false);
+  });
+});

package/tests/facade-base.test.ts

@@ -0,0 +1,80 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { Container } from "inversify";
+import { Application } from "../src/foundation/application";
+import Facade from "../src/support/facades/facade";
+
+class BrokenFacade extends Facade {
+  static callAccessorForTest() {
+    return (this as unknown as { getFacadeAccessor: () => unknown }).getFacadeAccessor();
+  }
+}
+
+class MethodFacade extends Facade {
+  protected static getFacadeAccessor() {
+    return "method.target";
+  }
+
+  static callMethod<T>(method: string, ...args: unknown[]) {
+    return (
+      this as unknown as {
+        callFacadeMethod: <R>(methodName: string, ...values: unknown[]) => R;
+      }
+    ).callFacadeMethod<T>(method, ...args);
+  }
+}
+
+class ConcreteFacade extends Facade {
+  protected static getFacadeAccessor() {
+    return "noop";
+  }
+}
+
+describe("Facade base", () => {
+  afterEach(() => {
+    Facade.clearResolvedInstances();
+    (Application as unknown as { container: Container | null }).container = null;
+  });
+
+  test("throws when accessor is not implemented", () => {
+    expect(() => BrokenFacade.callAccessorForTest()).toThrow(
+      "Facade does not implement getFacadeAccessor().",
+    );
+  });
+
+  test("callFacadeMethod dispatches to target method", () => {
+    const container = new Container();
+    container.bind("method.target").toConstantValue({
+      sum: (a: number, b: number) => a + b,
+    });
+    (Application as unknown as { container: Container | null }).container = container;
+
+    expect(MethodFacade.callMethod<number>("sum", 2, 3)).toBe(5);
+  });
+
+  test("callFacadeMethod throws for missing target method", () => {
+    const container = new Container();
+    container.bind("method.target").toConstantValue({});
+    (Application as unknown as { container: Container | null }).container = container;
+
+    expect(() => MethodFacade.callMethod("missing")).toThrow(
+      "Method [missing] does not exist on resolved facade instance.",
+    );
+  });
+
+  test("can clear a single resolved instance", () => {
+    const container = new Container();
+    container.bind("method.target").toConstantValue({
+      value: () => "cached",
+    });
+    (Application as unknown as { container: Container | null }).container = container;
+
+    expect(MethodFacade.callMethod<string>("value")).toBe("cached");
+    Facade.clearResolvedInstance("method.target");
+    expect(MethodFacade.callMethod<string>("value")).toBe("cached");
+  });
+
+  test("base facade constructor is invokable through subclass", () => {
+    const instance = new ConcreteFacade();
+    expect(instance).toBeInstanceOf(ConcreteFacade);
+  });
+});

package/tests/filesystem.test.ts

@@ -0,0 +1,81 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { FileSystem } from "../src/filesystem/filesystem";
+import LocalAdapter, { __localAdapterTesting } from "../src/filesystem/adapters/local";
+
+describe("FileSystem domain", () => {
+  afterEach(() => {
+    (
+      globalThis as {
+        __iocConfigGlobForTests?: unknown;
+      }
+    ).__iocConfigGlobForTests = undefined;
+  });
+
+  test("delegates loading to adapter and supports replacing adapter", () => {
+    const calls: string[] = [];
+    const adapterA = {
+      loadConfigItems: (basePath: string) => {
+        calls.push(`a:${basePath}`);
+        return { app: { name: "A" } };
+      },
+    };
+    const adapterB = {
+      loadConfigItems: (basePath: string) => {
+        calls.push(`b:${basePath}`);
+        return { app: { name: "B" } };
+      },
+    };
+
+    const filesystem = new FileSystem(adapterA);
+    expect(filesystem.loadConfigItems("./")).toEqual({ app: { name: "A" } });
+
+    filesystem.setAdapter(adapterB);
+    expect(filesystem.loadConfigItems("./src")).toEqual({ app: { name: "B" } });
+    expect(calls).toEqual(["a:./", "b:./src"]);
+  });
+
+  test("loads config defaults from matching directories", () => {
+    (
+      globalThis as {
+        __iocConfigGlobForTests?: (
+          pattern: string | string[],
+          options?: { eager?: boolean },
+        ) => Record<string, unknown>;
+      }
+    ).__iocConfigGlobForTests = () => ({
+      "/src/config/app.ts": { default: { name: "App" } },
+      "/src/config/cache.ts": { default: { driver: "memory" } },
+      "/src/config/no-default.ts": { named: true },
+      "/ignored/config/app.ts": { default: { name: "Ignored" } },
+    });
+
+    const adapter = new LocalAdapter();
+
+    expect(adapter.loadConfigItems("./src")).toEqual({
+      app: { name: "App" },
+      cache: { driver: "memory" },
+    });
+  });
+
+  test("helper functions normalize and match config paths", () => {
+    expect(__localAdapterTesting.fileNameWithoutExtension("/src/config/app.ts")).toBe("app");
+    expect(__localAdapterTesting.normalizeBasePath("./")).toBe("");
+    expect(__localAdapterTesting.normalizeBasePath("./src")).toBe("src");
+    expect(__localAdapterTesting.isPathInConfigDirectories("/src/config/app.ts", "./")).toBe(
+      true,
+    );
+    expect(
+      __localAdapterTesting.isPathInConfigDirectories(
+        "/workspace/src/config/app.ts",
+        "/workspace",
+      ),
+    ).toBe(true);
+    expect(__localAdapterTesting.isPathInConfigDirectories("/tmp/elsewhere/conf/app.ts", "./"))
+      .toBe(false);
+  });
+
+  test("returns empty config when no glob implementation is available", () => {
+    const adapter = new LocalAdapter();
+    expect(adapter.loadConfigItems("./")).toEqual({});
+  });
+});

package/tests/runtime-react.test.tsx

@@ -0,0 +1,37 @@
+import { describe, expect, test } from "bun:test";
+import { Container } from "inversify";
+import React from "react";
+import { renderToString } from "react-dom/server";
+import { ApplicationProvider, useService } from "../src/runtimes/react";
+
+describe("React runtime", () => {
+  test("ApplicationProvider + useService resolves from container", () => {
+    const container = new Container();
+    const token = Symbol("token");
+    container.bind(token).toConstantValue("resolved");
+
+    function Probe() {
+      const value = useService<string>(token);
+      return <div>{value}</div>;
+    }
+
+    const html = renderToString(
+      <ApplicationProvider container={container}>
+        <Probe />
+      </ApplicationProvider>,
+    );
+
+    expect(html).toContain("resolved");
+  });
+
+  test("useService throws when provider is missing", () => {
+    function Probe() {
+      useService("missing");
+      return null;
+    }
+
+    expect(() => renderToString(<Probe />)).toThrow(
+      "Application container is not available in React context.",
+    );
+  });
+});

package/tests/service-provider.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, test } from "bun:test";
+import ServiceProvider, {
+  DeferrableServiceProvider,
+} from "../src/support/service-provider";
+import { Container } from "inversify";
+
+describe("ServiceProvider base classes", () => {
+  test("default register and boot are no-ops", () => {
+    const provider = new ServiceProvider();
+    const container = new Container();
+
+    expect(provider.register({ container })).toBeUndefined();
+    expect(provider.boot({ container })).toBeUndefined();
+  });
+
+  test("deferrable provider default provides list is empty", () => {
+    const provider = new DeferrableServiceProvider();
+    const container = new Container();
+    expect(provider.register({ container })).toBeUndefined();
+    expect(provider.boot({ container })).toBeUndefined();
+    expect(provider.provides()).toEqual([]);
+  });
+});

package/tests/storage-facade.test.ts

@@ -0,0 +1,46 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { Container } from "inversify";
+import { Application } from "../src/foundation/application";
+import StorageManager from "../src/storage/manager";
+import MemoryStorageAdapter from "../src/storage/adapters/memory";
+import Storage from "../src/support/facades/storage";
+import Facade from "../src/support/facades/facade";
+
+describe("Storage facade", () => {
+  afterEach(() => {
+    Facade.clearResolvedInstances();
+    (Application as unknown as { container: Container | null }).container = null;
+  });
+
+  test("resolves manager and delegates methods", async () => {
+    const container = new Container();
+    const manager = new StorageManager({ memory: new MemoryStorageAdapter() }, "memory");
+    container.bind("storage").toConstantValue(manager);
+    container.bind(StorageManager).toConstantValue(manager);
+    (Application as unknown as { container: Container | null }).container = container;
+
+    await Storage.set("name", "ioc");
+    expect(await Storage.get("name")).toBe("ioc");
+    expect(await Storage.has("name")).toBe(true);
+    expect(await Storage.keys()).toEqual(["name"]);
+    expect(Storage.drv()).toBe(manager.drv());
+    expect(Storage.drv("memory")).toBe(manager.drv("memory"));
+    Storage.use("memory");
+    await Storage.delete("name");
+    expect(await Storage.get("name")).toBeNull();
+    await Storage.set("x", 1);
+    await Storage.clear();
+    expect(await Storage.keys()).toEqual([]);
+  });
+
+  test("uses expected facade accessor", () => {
+    expect((Storage as unknown as { getFacadeAccessor: () => string }).getFacadeAccessor()).toBe(
+      "storage",
+    );
+  });
+
+  test("facade class constructor is defined", () => {
+    const instance = new (Storage as unknown as { new (): object })();
+    expect(instance).toBeTruthy();
+  });
+});