@raubjo/architect-core 0.1.0 → 0.1.1

package/src/config/app.ts

@@ -1,5 +0,0 @@
-export default {
-  name: "Application",
-  timezone: "UTC",
-  locale: "en",
-};

package/src/rendering/adapters/react.tsx

@@ -1,27 +0,0 @@
-import ReactDOM from "react-dom/client";
-import { createElement } from "react";
-import { ApplicationProvider } from "../../runtimes/react";
-import type { RendererAdapter, RendererContext } from "../renderer";
-import type { Cleanup } from "../../support/service-provider";
-
-export default class ReactRenderer implements RendererAdapter {
-  constructor() {}
-
-  render({ RootComponent, container, rootElementId }: RendererContext): Cleanup {
-    const mountNode = document.getElementById(rootElementId);
-    if (!mountNode) {
-      throw new Error(`Missing mount node #${rootElementId}.`);
-    }
-
-    const root = ReactDOM.createRoot(mountNode);
-    root.render(
-      createElement(
-        ApplicationProvider,
-        { container },
-        createElement(RootComponent),
-      ),
-    );
-
-    return () => root.unmount();
-  }
-}

package/src/rendering/renderer.ts

@@ -1,13 +0,0 @@
-import type { Cleanup, ServiceProviderContext } from "../support/service-provider";
-import type { ReactElement } from "react";
-
-export type RootComponent = () => ReactElement | null;
-
-export type RendererContext = ServiceProviderContext & {
-  RootComponent: RootComponent;
-  rootElementId: string;
-};
-
-export interface RendererAdapter {
-  render(context: RendererContext): void | Cleanup;
-}

package/src/support/providers/config-service-provider.ts

@@ -1,19 +0,0 @@
-import appConfig from "../../config/app";
-import ConfigRepository, { type ConfigItems } from "../../config/repository";
-import ServiceProvider, { type ServiceProviderContext } from "../service-provider";
-
-export default class ConfigServiceProvider extends ServiceProvider {
-  protected items: ConfigItems;
-
-  constructor(items: ConfigItems = { app: appConfig }) {
-    super();
-    this.items = items;
-  }
-
-  register({ container }: ServiceProviderContext): void {
-    const repository = new ConfigRepository(this.items);
-
-    container.bind("config").toConstantValue(repository);
-    container.bind(ConfigRepository).toConstantValue(repository);
-  }
-}

package/tests/application.test.ts

@@ -1,236 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import ReactDOM from "react-dom/client";
-import ConfigRepository from "../src/config/repository";
-import { __applicationTesting, Application } from "../src/foundation/application";
-import ServiceProvider from "../src/support/service-provider";
-
-describe("Application", () => {
-  afterEach(() => {
-    (globalThis as { window?: unknown; document?: unknown }).window = undefined;
-    (globalThis as { window?: unknown; document?: unknown }).document = undefined;
-    (
-      globalThis as { __iocConfigGlobForTests?: unknown }
-    ).__iocConfigGlobForTests = undefined;
-    Application.clearConfigCache();
-  });
-
-  test("make throws when container is not initialized", () => {
-    expect(() => Application.make("config")).toThrow(
-      "Application container is not available. Call run() first.",
-    );
-  });
-
-  test("run with custom renderer executes lifecycle and cleanup in reverse order", () => {
-    const calls: string[] = [];
-    let beforeUnload: (() => void) | undefined;
-
-    (globalThis as { window: { addEventListener: (event: string, cb: () => void) => void } })
-      .window = {
-      addEventListener: (_event, cb) => {
-        beforeUnload = cb;
-      },
-    };
-
-    class DemoProvider extends ServiceProvider {
-      register({ container }: { container: { bind: (id: string) => { toConstantValue: (v: unknown) => void } } }) {
-        calls.push("provider.register");
-        container.bind("demo").toConstantValue("value");
-        return () => calls.push("provider.register.cleanup");
-      }
-
-      boot() {
-        calls.push("provider.boot");
-        return () => calls.push("provider.boot.cleanup");
-      }
-    }
-
-    const app = Application.configure("./")
-      .withProviders([new DemoProvider()])
-      .withServices(({ container }) => {
-        calls.push("services");
-        container.bind("services.value").toConstantValue(1);
-        return () => calls.push("services.cleanup");
-      })
-      .withStartup(() => {
-        calls.push("startup");
-        return () => calls.push("startup.cleanup");
-      })
-      .withRoot(() => null)
-      .withRenderer({
-        render: () => {
-          calls.push("renderer");
-          return () => calls.push("renderer.cleanup");
-        },
-      });
-
-    const running = app.run();
-    expect(Application.make("demo")).toBe("value");
-    expect(Application.make("storage")).toBeTruthy();
-    expect(Application.make("cache")).toBeTruthy();
-    expect(running.container.get("services.value")).toBe(1);
-    expect(calls).toEqual([
-      "provider.register",
-      "services",
-      "provider.boot",
-      "startup",
-      "renderer",
-    ]);
-
-    expect(typeof beforeUnload).toBe("function");
-    beforeUnload?.();
-
-    expect(calls).toEqual([
-      "provider.register",
-      "services",
-      "provider.boot",
-      "startup",
-      "renderer",
-      "renderer.cleanup",
-      "startup.cleanup",
-      "provider.boot.cleanup",
-      "services.cleanup",
-      "provider.register.cleanup",
-    ]);
-
-    expect(() => Application.make("demo")).toThrow(
-      "Application container is not available. Call run() first.",
-    );
-  });
-
-  test("exposes helper behavior used for config discovery", () => {
-    expect(__applicationTesting.fileNameWithoutExtension("/src/config/app.ts")).toBe("app");
-    expect(__applicationTesting.normalizeBasePath("./")).toBe("");
-    expect(__applicationTesting.normalizeBasePath("./src")).toBe("src");
-    expect(__applicationTesting.isPathInConfigDirectories("/src/config/app.ts", "./")).toBe(
-      true,
-    );
-    expect(
-      __applicationTesting.isPathInConfigDirectories(
-        "/workspace/src/config/app.ts",
-        "/workspace",
-      ),
-    ).toBe(true);
-  });
-
-  test("loads config modules through glob loader and caches by basePath", () => {
-    (
-      globalThis as {
-        __iocConfigGlobForTests?: (
-          pattern: string | string[],
-          options?: { eager?: boolean },
-        ) => Record<string, unknown>;
-      }
-    ).__iocConfigGlobForTests = () => ({
-      "/src/config/app.ts": { default: { name: "From App Config" } },
-      "/src/config/cache.ts": { default: { store: "memory" } },
-      "/other/path/ignored.ts": { default: { nope: true } },
-    });
-
-    (globalThis as { window: { addEventListener: (event: string, cb: () => void) => void } })
-      .window = {
-      addEventListener: () => {},
-    };
-
-    const first = Application.configure("./src").run();
-    const second = Application.configure("./src").run();
-
-    const firstConfig = first.container.get(ConfigRepository);
-    const secondConfig = second.container.get(ConfigRepository);
-
-    expect(firstConfig.get("app")).toEqual({ name: "From App Config" });
-    expect(firstConfig.get("cache")).toEqual({ store: "memory" });
-    expect(firstConfig.get("ignored")).toBeNull();
-    expect(firstConfig.all()).toEqual(secondConfig.all());
-    expect(firstConfig.all()).not.toBe(secondConfig.all());
-
-    // Cached source config should be cloned into each app instance.
-    firstConfig.set("cache.store", "updated");
-    expect(secondConfig.get("cache.store")).toBe("memory");
-
-    first.stop();
-    second.stop();
-  });
-
-  test("renderer requires root component", () => {
-    (globalThis as { window: { addEventListener: (event: string, cb: () => void) => void } })
-      .window = {
-      addEventListener: () => {},
-    };
-
-    const app = Application.configure("./").withRenderer({ render: () => () => {} });
-
-    expect(() => app.run()).toThrow(
-      "Root component is required when using a custom renderer.",
-    );
-  });
-
-  test("default react renderer throws if mount node is missing", () => {
-    (globalThis as { window: { addEventListener: (event: string, cb: () => void) => void } })
-      .window = {
-      addEventListener: () => {},
-    };
-    (globalThis as { document: { getElementById: (id: string) => null } }).document = {
-      getElementById: () => null,
-    };
-
-    const app = Application.configure("./").withRoot(() => null);
-
-    expect(() => app.run()).toThrow("Missing mount node #root.");
-  });
-
-  test("default react renderer mounts and unmounts when stopped", () => {
-    let beforeUnload: (() => void) | undefined;
-    let rendered = 0;
-    let unmounted = 0;
-
-    (globalThis as { window: { addEventListener: (event: string, cb: () => void) => void } })
-      .window = {
-      addEventListener: (_event, cb) => {
-        beforeUnload = cb;
-      },
-    };
-    (globalThis as { document: { getElementById: (id: string) => object | null } }).document = {
-      getElementById: () => ({}),
-    };
-
-    const originalCreateRoot = (ReactDOM as { createRoot: (node: unknown) => unknown }).createRoot;
-    (ReactDOM as { createRoot: (node: unknown) => { render: () => void; unmount: () => void } })
-      .createRoot = () => ({
-      render: () => {
-        rendered += 1;
-      },
-      unmount: () => {
-        unmounted += 1;
-      },
-    });
-
-    try {
-      const running = Application.configure("./").withRoot(() => null).run();
-      expect(rendered).toBe(1);
-      running.stop();
-      expect(unmounted).toBe(1);
-      // Stop twice should still be safe if beforeunload callback also runs.
-      beforeUnload?.();
-      expect(unmounted).toBe(2);
-    } finally {
-      (
-        ReactDOM as { createRoot: (node: unknown) => unknown }
-      ).createRoot = originalCreateRoot;
-    }
-  });
-
-  test("uses fallback no-op renderer cleanup when custom renderer returns nothing", () => {
-    (globalThis as { window: { addEventListener: (event: string, cb: () => void) => void } })
-      .window = {
-      addEventListener: (_event, cb) => {
-        cb();
-      },
-    };
-
-    const app = Application.configure("./")
-      .withRoot(() => null)
-      .withRenderer({ render: () => undefined });
-
-    expect(() => app.run()).not.toThrow();
-  });
-});

package/tests/cache-facade.test.ts

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

package/tests/cache.test.ts

@@ -1,68 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,88 +0,0 @@
-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

@@ -1,96 +0,0 @@
-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",
-      },
-    });
-  });
-});