@raubjo/architect-core 0.1.0 → 0.1.2

package/tests/config-repository.test.ts

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

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

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

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

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

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

package/tests/storage.test.ts

@@ -1,264 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import ConfigRepository from "../src/config/repository";
-import IndexedDbAdapter from "../src/storage/adapters/indexed-db";
-import LocalStorageAdapter from "../src/storage/adapters/local-storage";
-import MemoryStorageAdapter from "../src/storage/adapters/memory";
-import StorageManager from "../src/storage/manager";
-
-class FakeWebStorage implements Storage {
-  protected data = new Map<string, string>();
-
-  get length(): number {
-    return this.data.size;
-  }
-
-  clear(): void {
-    this.data.clear();
-  }
-
-  getItem(key: string): string | null {
-    return this.data.get(key) ?? null;
-  }
-
-  key(index: number): string | null {
-    const keys = Array.from(this.data.keys());
-    return keys[index] ?? null;
-  }
-
-  removeItem(key: string): void {
-    this.data.delete(key);
-  }
-
-  setItem(key: string, value: string): void {
-    this.data.set(key, value);
-  }
-}
-
-type RequestLike<T> = Partial<IDBRequest<T>> & {
-  onsuccess: ((this: IDBRequest<T>, ev: Event) => unknown) | null;
-  onerror: ((this: IDBRequest<T>, ev: Event) => unknown) | null;
-  onupgradeneeded?: ((this: IDBOpenDBRequest, ev: IDBVersionChangeEvent) => unknown) | null;
-};
-
-function makeRequest<T>(resolveValue: () => T, shouldFail = false): IDBRequest<T> {
-  const request: RequestLike<T> = {
-    onsuccess: null,
-    onerror: null,
-  };
-
-  queueMicrotask(() => {
-    if (shouldFail) {
-      request.error = new Error("fail") as unknown as DOMException;
-      request.onerror?.call(request as IDBRequest<T>, new Event("error"));
-      return;
-    }
-
-    request.result = resolveValue();
-    request.onsuccess?.call(request as IDBRequest<T>, new Event("success"));
-  });
-
-  return request as IDBRequest<T>;
-}
-
-function createIndexedDbFactory(options: { failOpen?: boolean; failGet?: boolean } = {}) {
-  const items = new Map<string, unknown>();
-  let hasStore = false;
-
-  const store: Partial<IDBObjectStore> = {
-    get: (key: IDBValidKey) => makeRequest(() => items.get(String(key)), options.failGet),
-    put: (value: unknown, key?: IDBValidKey) =>
-      makeRequest(() => {
-        items.set(String(key), value);
-        return key as IDBValidKey;
-      }),
-    count: (key?: IDBValidKey | IDBKeyRange) =>
-      makeRequest(() => (items.has(String(key)) ? 1 : 0)),
-    delete: (key: IDBValidKey | IDBKeyRange) =>
-      makeRequest(() => {
-        items.delete(String(key));
-        return undefined;
-      }),
-    clear: () =>
-      makeRequest(() => {
-        items.clear();
-        return undefined;
-      }),
-    getAllKeys: () => makeRequest(() => Array.from(items.keys()) as Array<IDBValidKey>),
-  };
-
-  const db: Partial<IDBDatabase> = {
-    objectStoreNames: {
-      contains: (name: string) => hasStore && name === "kv",
-      item: () => null,
-      length: 0,
-      [Symbol.iterator]: function* iterator() {},
-    } as DOMStringList,
-    createObjectStore: () => {
-      hasStore = true;
-      return store as IDBObjectStore;
-    },
-    transaction: () =>
-      ({
-        objectStore: () => store as IDBObjectStore,
-      }) as IDBTransaction,
-  };
-
-  const factory: Pick<IDBFactory, "open"> = {
-    open: () => {
-      const request: RequestLike<IDBDatabase> = {
-        onsuccess: null,
-        onerror: null,
-        onupgradeneeded: null,
-      };
-
-      queueMicrotask(() => {
-        if (options.failOpen) {
-          request.error = new Error("open failed") as unknown as DOMException;
-          request.onerror?.call(request as IDBOpenDBRequest, new Event("error"));
-          return;
-        }
-
-        request.result = db as IDBDatabase;
-        request.onupgradeneeded?.call(
-          request as IDBOpenDBRequest,
-          new Event("upgradeneeded") as IDBVersionChangeEvent,
-        );
-        request.onsuccess?.call(request as IDBOpenDBRequest, new Event("success"));
-      });
-
-      return request as IDBOpenDBRequest;
-    },
-  };
-
-  return { factory, items };
-}
-
-describe("Storage adapters and manager", () => {
-  test("memory adapter reads/writes/deletes/clears", async () => {
-    const adapter = new MemoryStorageAdapter();
-
-    await adapter.set("a", 1);
-    expect(await adapter.get<number>("a")).toBe(1);
-    expect(await adapter.has("a")).toBe(true);
-    expect(await adapter.keys()).toEqual(["a"]);
-    await adapter.delete("a");
-    expect(await adapter.get("a")).toBeNull();
-    await adapter.set("b", 2);
-    await adapter.clear();
-    expect(await adapter.keys()).toEqual([]);
-  });
-
-  test("local storage adapter serializes values", async () => {
-    const storage = new FakeWebStorage();
-    const adapter = new LocalStorageAdapter(storage);
-
-    await adapter.set("name", { v: "ioc" });
-    expect(await adapter.get<{ v: string }>("name")).toEqual({ v: "ioc" });
-    expect(await adapter.has("name")).toBe(true);
-    expect(await adapter.keys()).toEqual(["name"]);
-    await adapter.delete("name");
-    expect(await adapter.get("name")).toBeNull();
-    await adapter.set("x", 1);
-    await adapter.clear();
-    expect(await adapter.keys()).toEqual([]);
-  });
-
-  test("indexed db adapter uses indexeddb when available", async () => {
-    const { factory, items } = createIndexedDbFactory();
-    const adapter = new IndexedDbAdapter({ factory, name: "ioc-test" });
-
-    await adapter.set("k", { n: 1 });
-    expect(items.get("k")).toEqual({ n: 1 });
-    expect(await adapter.get<{ n: number }>("k")).toEqual({ n: 1 });
-    expect(await adapter.has("k")).toBe(true);
-    expect(await adapter.keys()).toEqual(["k"]);
-    await adapter.delete("k");
-    expect(await adapter.get("k")).toBeNull();
-    await adapter.set("z", true);
-    await adapter.clear();
-    expect(await adapter.keys()).toEqual([]);
-  });
-
-  test("indexed db adapter falls back to memory when indexeddb is unavailable or fails", async () => {
-    const fallback = new MemoryStorageAdapter();
-    const unavailable = new IndexedDbAdapter({ factory: null, fallback });
-
-    await unavailable.set("a", 1);
-    expect(await unavailable.get<number>("a")).toBe(1);
-    expect(await unavailable.has("a")).toBe(true);
-    expect(await unavailable.keys()).toEqual(["a"]);
-    await unavailable.delete("a");
-    expect(await unavailable.has("a")).toBe(false);
-    await unavailable.set("b", 2);
-    await unavailable.clear();
-    expect(await unavailable.keys()).toEqual([]);
-
-    const failedOpenFactory: Pick<IDBFactory, "open"> = {
-      open: () => null as unknown as IDBOpenDBRequest,
-    };
-    const failedOpen = new IndexedDbAdapter({ factory: failedOpenFactory, fallback });
-    await failedOpen.set("x", 42);
-    expect(await failedOpen.get<number>("x")).toBe(42);
-
-    const { factory: failOpenFactory } = createIndexedDbFactory({ failOpen: true });
-    const failedOpenEvent = new IndexedDbAdapter({ factory: failOpenFactory, fallback });
-    expect(await failedOpenEvent.get("none")).toBeNull();
-
-    const { factory: failGetFactory } = createIndexedDbFactory({ failGet: true });
-    const failedGet = new IndexedDbAdapter({ factory: failGetFactory, fallback });
-    await failedGet.set("y", 7);
-    expect(await failedGet.get<number>("y")).toBeNull();
-
-    const rejectingFallback = {
-      get: async () => null,
-      set: async () => {
-        throw new Error("set failed");
-      },
-      has: async () => false,
-      delete: async () => {},
-      clear: async () => {},
-      keys: async () => [],
-    };
-    const rejected = new IndexedDbAdapter({ factory: null, fallback: rejectingFallback });
-    await expect(rejected.set("bad", 1)).rejects.toThrow("set failed");
-  });
-
-  test("storage manager chooses and switches drivers", async () => {
-    const memory = new MemoryStorageAdapter();
-    const alt = new MemoryStorageAdapter();
-    const manager = new StorageManager({ memory, alt }, "memory");
-
-    await manager.set("k", 1);
-    expect(await manager.get("k")).toBe(1);
-    manager.use("alt");
-    expect(manager.drv()).toBe(alt);
-    expect(() => manager.drv("missing")).toThrow("Storage driver [missing] is not defined.");
-  });
-
-  test("storage manager builds defaults from config", () => {
-    const originalWindow = (globalThis as { window?: unknown }).window;
-    const originalIndexedDb = (globalThis as { indexedDB?: unknown }).indexedDB;
-
-    try {
-      (globalThis as { window?: unknown }).window = {
-        localStorage: new FakeWebStorage(),
-      };
-      (globalThis as { indexedDB?: unknown }).indexedDB = createIndexedDbFactory().factory;
-
-      const manager = StorageManager.fromConfig(
-        new ConfigRepository({
-          storage: {
-            driver: "local",
-          },
-        }),
-      );
-
-      expect(manager.drv()).toBeTruthy();
-      expect(manager.drv("indexed")).toBeTruthy();
-      expect(manager.drv("memory")).toBeTruthy();
-    } finally {
-      (globalThis as { window?: unknown }).window = originalWindow;
-      (globalThis as { indexedDB?: unknown }).indexedDB = originalIndexedDb;
-    }
-  });
-});