@raubjo/architect-core 0.1.0

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@raubjo/architect-core",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "bun test",
+    "test:coverage": "bun test --coverage"
+  },
+  "exports": {
+    ".": "./src/index.ts",
+    "./application": "./src/foundation/application.ts",
+    "./config/app": "./src/config/app.ts",
+    "./config/env": "./src/config/env.ts",
+    "./config/repository": "./src/config/repository.ts",
+    "./cache/manager": "./src/cache/manager.ts",
+    "./cache/cache": "./src/cache/cache.ts",
+    "./facades/cache": "./src/support/facades/cache.ts",
+    "./storage/manager": "./src/storage/manager.ts",
+    "./storage/storage": "./src/storage/storage.ts",
+    "./storage/adapters/memory": "./src/storage/adapters/memory.ts",
+    "./storage/adapters/local-storage": "./src/storage/adapters/local-storage.ts",
+    "./storage/adapters/indexed-db": "./src/storage/adapters/indexed-db.ts",
+    "./facades/storage": "./src/support/facades/storage.ts",
+    "./filesystem/filesystem": "./src/filesystem/filesystem.ts",
+    "./filesystem/local-adapter": "./src/filesystem/adapters/local.ts",
+    "./rendering/renderer": "./src/rendering/renderer.ts",
+    "./rendering/react": "./src/rendering/adapters/react.tsx",
+    "./facades/config": "./src/support/facades/config.ts",
+    "./providers/config-service-provider": "./src/support/providers/config-service-provider.ts",
+    "./runtimes/react": "./src/runtimes/react.tsx",
+    "./str": "./src/support/str.ts",
+    "./service-provider": "./src/support/service-provider.ts",
+    "./facade": "./src/support/facades/facade.ts"
+  },
+  "devDependencies": {
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3"
+  }
+}

package/src/cache/cache.ts

@@ -0,0 +1,3 @@
+import type { StorageAdapter } from "../storage/storage";
+
+export type CacheStore = StorageAdapter;

package/src/cache/manager.ts

@@ -0,0 +1,115 @@
+import type ConfigRepository from "../config/repository";
+import IndexedDbAdapter from "../storage/adapters/indexed-db";
+import LocalStorageAdapter from "../storage/adapters/local-storage";
+import MemoryStorageAdapter from "../storage/adapters/memory";
+import type { StorageAdapter } from "../storage/storage";
+import type { CacheStore } from "./cache";
+
+type CacheStoreConfig = {
+  driver?: string;
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export default class CacheManager implements StorageAdapter {
+  protected stores: Record<string, CacheStore>;
+  protected active: string;
+
+  constructor(stores: Record<string, CacheStore>, active = "memory") {
+    this.stores = stores;
+    this.active = active in this.stores ? active : firstStoreName(this.stores);
+  }
+
+  static fromConfig(config: ConfigRepository): CacheManager {
+    const stores = CacheManager.storesFromConfig(config);
+    const active = config.string("cache.default", "memory");
+
+    return new CacheManager(stores, active);
+  }
+
+  protected static storesFromConfig(config: ConfigRepository): Record<string, CacheStore> {
+    const baseDrivers = CacheManager.defaultDrivers();
+    const configured = config.get<Record<string, unknown>>("cache.stores", {}) ?? {};
+    if (!isRecord(configured) || Object.keys(configured).length === 0) {
+      return baseDrivers;
+    }
+
+    const stores: Record<string, CacheStore> = {};
+    for (const [name, storeConfig] of Object.entries(configured)) {
+      const driver = resolveDriver(storeConfig, name);
+      stores[name] = baseDrivers[driver] ?? baseDrivers.memory;
+    }
+
+    return stores;
+  }
+
+  protected static defaultDrivers(): Record<string, CacheStore> {
+    const memory = new MemoryStorageAdapter();
+    const hasWindow = typeof window !== "undefined";
+    const hasLocal = hasWindow && typeof window.localStorage !== "undefined";
+    const hasIndexed = typeof globalThis.indexedDB !== "undefined";
+
+    return {
+      memory,
+      local: hasLocal ? new LocalStorageAdapter(window.localStorage) : memory,
+      indexed: hasIndexed ? new IndexedDbAdapter() : memory,
+    };
+  }
+
+  store(name?: string): CacheStore {
+    const target = typeof name === "string" ? name : this.active;
+    if (!(target in this.stores)) {
+      throw new Error(`Cache store [${target}] is not defined.`);
+    }
+
+    return this.stores[target];
+  }
+
+  use(name: string): this {
+    this.active = this.store(name) ? name : this.active;
+    return this;
+  }
+
+  get<T = unknown>(key: string): Promise<T | null> {
+    return this.store().get<T>(key);
+  }
+
+  set<T = unknown>(key: string, value: T): Promise<void> {
+    return this.store().set<T>(key, value);
+  }
+
+  has(key: string): Promise<boolean> {
+    return this.store().has(key);
+  }
+
+  delete(key: string): Promise<void> {
+    return this.store().delete(key);
+  }
+
+  clear(): Promise<void> {
+    return this.store().clear();
+  }
+
+  keys(): Promise<string[]> {
+    return this.store().keys();
+  }
+}
+
+function firstStoreName(stores: Record<string, CacheStore>): string {
+  if ("memory" in stores) {
+    return "memory";
+  }
+
+  return Object.keys(stores)[0];
+}
+
+function resolveDriver(value: unknown, fallback: string): string {
+  if (!isRecord(value)) {
+    return fallback;
+  }
+
+  const storeConfig = value as CacheStoreConfig;
+  return typeof storeConfig.driver === "string" ? storeConfig.driver : fallback;
+}

package/src/config/app.ts

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

package/src/config/clone.ts

@@ -0,0 +1,9 @@
+import type { ConfigItems } from "./repository";
+
+export function cloneConfigItems(items: ConfigItems): ConfigItems {
+  if (typeof structuredClone === "function") {
+    return structuredClone(items) as ConfigItems;
+  }
+
+  return JSON.parse(JSON.stringify(items)) as ConfigItems;
+}

package/src/config/env.global.d.ts

@@ -0,0 +1,5 @@
+declare global {
+  function env<T = unknown>(key: string, defaultValue?: T | null): T | unknown | null;
+}
+
+export {};

package/src/config/env.ts

@@ -0,0 +1,79 @@
+type EnvMap = Record<string, unknown>;
+
+function normalizeEnvValue(value: unknown): unknown {
+  if (typeof value !== "string") {
+    return value;
+  }
+
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "true" || normalized === "(true)") {
+    return true;
+  }
+
+  if (normalized === "false" || normalized === "(false)") {
+    return false;
+  }
+
+  if (normalized === "null" || normalized === "(null)") {
+    return null;
+  }
+
+  if (normalized === "empty" || normalized === "(empty)") {
+    return "";
+  }
+
+  return value;
+}
+
+function resolveProcessEnv(): EnvMap {
+  const processValue = (
+    globalThis as { process?: { env?: EnvMap } }
+  ).process;
+
+  if (!processValue?.env) {
+    return {};
+  }
+
+  return processValue.env;
+}
+
+function resolveImportMetaEnv(): EnvMap {
+  const testEnv = (
+    globalThis as {
+      __iocImportMetaEnvForTests?: EnvMap;
+    }
+  ).__iocImportMetaEnvForTests;
+  if (testEnv) {
+    return testEnv;
+  }
+
+  const meta = import.meta as ImportMeta & { env?: EnvMap };
+  return meta.env ?? {};
+}
+
+export function env<T = unknown>(key: string, defaultValue: T | null = null): T | unknown | null {
+  const importMetaEnv = resolveImportMetaEnv();
+  if (key in importMetaEnv) {
+    return normalizeEnvValue(importMetaEnv[key]);
+  }
+
+  const processEnv = resolveProcessEnv();
+  if (key in processEnv) {
+    return normalizeEnvValue(processEnv[key]);
+  }
+
+  return defaultValue;
+}
+
+export function registerGlobalEnv(): void {
+  const globalScope = globalThis as { env?: typeof env };
+  if (typeof globalScope.env !== "function") {
+    globalScope.env = env;
+  }
+}
+
+export const __envTesting = {
+  normalizeEnvValue,
+  resolveImportMetaEnv,
+  resolveProcessEnv,
+};

package/src/config/repository.ts

@@ -0,0 +1,204 @@
+export type ConfigItems = Record<string, unknown>;
+export type ConfigDefaults = Record<string | number, unknown>;
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function resolveDefault<T>(defaultValue: T | (() => T)): T {
+  return typeof defaultValue === "function" ? (defaultValue as () => T)() : defaultValue;
+}
+
+function dataGet(source: unknown, path: string, defaultValue: unknown = null): unknown {
+  if (!path) {
+    return source;
+  }
+
+  const segments = path.split(".");
+  let cursor: unknown = source;
+
+  for (const segment of segments) {
+    if (isPlainObject(cursor) && segment in cursor) {
+      cursor = cursor[segment];
+      continue;
+    }
+
+    return resolveDefault(defaultValue);
+  }
+
+  return cursor;
+}
+
+function dataSet(target: Record<string, unknown>, path: string, value: unknown): void {
+  const segments = path.split(".");
+  let cursor: Record<string, unknown> = target;
+
+  for (let i = 0; i < segments.length; i += 1) {
+    const segment = segments[i];
+    const isLast = i === segments.length - 1;
+
+    if (isLast) {
+      cursor[segment] = value;
+      return;
+    }
+
+    if (!isPlainObject(cursor[segment])) {
+      cursor[segment] = {};
+    }
+
+    cursor = cursor[segment] as Record<string, unknown>;
+  }
+}
+
+function dataForget(target: Record<string, unknown>, path: string): void {
+  const segments = path.split(".");
+  let cursor: Record<string, unknown> = target;
+
+  for (let i = 0; i < segments.length; i += 1) {
+    const segment = segments[i];
+    const isLast = i === segments.length - 1;
+
+    if (isLast) {
+      delete cursor[segment];
+      return;
+    }
+
+    if (!isPlainObject(cursor[segment])) {
+      return;
+    }
+
+    cursor = cursor[segment] as Record<string, unknown>;
+  }
+}
+
+export default class ConfigRepository {
+  protected items: ConfigItems;
+
+  constructor(items: ConfigItems = {}) {
+    this.items = items;
+  }
+
+  has(key: string | string[]): boolean {
+    const keys = Array.isArray(key) ? key : [key];
+    for (const configKey of keys) {
+      if (this.get(configKey) == null) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  get<T = unknown>(
+    key: string | string[],
+    defaultValue: T | (() => T) | null = null,
+  ): T | Record<string, unknown> | null {
+    if (Array.isArray(key)) {
+      return this.getMany(key);
+    }
+
+    return dataGet(this.items, key, defaultValue) as T | null;
+  }
+
+  getMany(keys: string[] | ConfigDefaults): Record<string, unknown> {
+    const results: Record<string, unknown> = {};
+
+    if (Array.isArray(keys)) {
+      for (const key of keys) {
+        results[key] = this.get(key);
+      }
+
+      return results;
+    }
+
+    for (const [key, defaultValue] of Object.entries(keys)) {
+      results[key] = this.get(key, defaultValue);
+    }
+
+    return results;
+  }
+
+  string(key: string, defaultValue: string | (() => string) | null = null): string {
+    const value = this.get<string>(key, defaultValue);
+    if (typeof value !== "string") {
+      throw new TypeError(`Configuration value [${key}] is not a string.`);
+    }
+
+    return value;
+  }
+
+  integer(key: string, defaultValue: number | (() => number) | null = null): number {
+    const value = this.get<number>(key, defaultValue);
+    if (!Number.isInteger(value)) {
+      throw new TypeError(`Configuration value [${key}] is not an integer.`);
+    }
+
+    return value;
+  }
+
+  float(key: string, defaultValue: number | (() => number) | null = null): number {
+    const value = this.get<number>(key, defaultValue);
+    if (typeof value !== "number" || Number.isNaN(value)) {
+      throw new TypeError(`Configuration value [${key}] is not a float.`);
+    }
+
+    return value;
+  }
+
+  boolean(key: string, defaultValue: boolean | (() => boolean) | null = null): boolean {
+    const value = this.get<boolean>(key, defaultValue);
+    if (typeof value !== "boolean") {
+      throw new TypeError(`Configuration value [${key}] is not a boolean.`);
+    }
+
+    return value;
+  }
+
+  array<T = unknown>(key: string, defaultValue: T[] | (() => T[]) | null = null): T[] {
+    const value = this.get<T[]>(key, defaultValue);
+    if (!Array.isArray(value)) {
+      throw new TypeError(`Configuration value [${key}] is not an array.`);
+    }
+
+    return value;
+  }
+
+  set(key: string | ConfigItems, value: unknown = null): void {
+    const payload = isPlainObject(key) ? key : { [key]: value };
+
+    for (const [configKey, configValue] of Object.entries(payload)) {
+      dataSet(this.items, configKey, configValue);
+    }
+  }
+
+  prepend(key: string, value: unknown): void {
+    const values = this.array<unknown>(key, []);
+    this.set(key, [value, ...values]);
+  }
+
+  push(key: string, value: unknown): void {
+    const values = this.array<unknown>(key, []);
+    values.push(value);
+    this.set(key, values);
+  }
+
+  all(): ConfigItems {
+    return this.items;
+  }
+
+  offsetExists(key: string): boolean {
+    return this.has(key);
+  }
+
+  offsetGet<T = unknown>(key: string): T | null {
+    return this.get<T>(key) as T | null;
+  }
+
+  offsetSet(key: string, value: unknown): void {
+    this.set(key, value);
+  }
+
+  offsetUnset(key: string): void {
+    dataForget(this.items, key);
+  }
+}

package/src/filesystem/adapters/local.ts

@@ -0,0 +1,104 @@
+import type { ConfigItems } from "../../config/repository";
+import type { FileSystemAdapter } from "../filesystem";
+
+type ConfigModule = { default?: unknown };
+type GlobLoader = (
+  pattern: string | string[],
+  options?: { eager?: boolean },
+) => Record<string, unknown>;
+
+function fileNameWithoutExtension(path: string): string {
+  const file = path.split("/").pop() ?? path;
+  return file.replace(/\.[^/.]+$/, "");
+}
+
+function normalizeBasePath(basePath: string): string {
+  const trimmed = basePath.trim();
+  if (!trimmed || trimmed === "." || trimmed === "./" || trimmed === "/") {
+    return "";
+  }
+
+  let normalized = trimmed.replace(/\\/g, "/");
+  normalized = normalized.replace(/^\.\//, "");
+  normalized = normalized.replace(/^\/+/, "");
+  normalized = normalized.replace(/\/+$/, "");
+
+  return normalized;
+}
+
+function isPathInConfigDirectories(path: string, basePath: string): boolean {
+  const normalizedPath = path.replace(/\\/g, "/");
+  const trimmedPath = normalizedPath.replace(/^\/+/, "");
+  const normalizedBasePath = normalizeBasePath(basePath);
+
+  const targets = normalizedBasePath
+    ? [`${normalizedBasePath}/config/`, `${normalizedBasePath}/src/config/`]
+    : ["config/", "src/config/"];
+
+  for (const target of targets) {
+    if (
+      trimmedPath.startsWith(target) ||
+      normalizedPath.includes(`/${target}`) ||
+      normalizedPath.endsWith(`/${target.slice(0, -1)}`)
+    ) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+export default class LocalAdapter implements FileSystemAdapter {
+  constructor() {}
+
+  loadConfigItems(basePath: string): ConfigItems {
+    const viteGlob = (
+      import.meta as ImportMeta & {
+        glob?: GlobLoader;
+      }
+    ).glob;
+    const testGlob = (
+      globalThis as {
+        __iocConfigGlobForTests?: GlobLoader;
+      }
+    ).__iocConfigGlobForTests;
+    const glob =
+      typeof viteGlob === "function"
+        ? viteGlob
+        : typeof testGlob === "function"
+          ? testGlob
+          : null;
+    if (!glob) {
+      return {};
+    }
+
+    const modules = glob(
+      [
+        "/config/*.{js,mjs,cjs,ts,mts,cts}",
+        "/src/config/*.{js,mjs,cjs,ts,mts,cts}",
+      ],
+      { eager: true },
+    ) as Record<string, unknown>;
+
+    const discovered: ConfigItems = {};
+    for (const [path, loaded] of Object.entries(modules)) {
+      if (!isPathInConfigDirectories(path, basePath)) {
+        continue;
+      }
+
+      const key = fileNameWithoutExtension(path);
+      const module = loaded as ConfigModule;
+      if (module && "default" in module && module.default !== undefined) {
+        discovered[key] = module.default;
+      }
+    }
+
+    return discovered;
+  }
+}
+
+export const __localAdapterTesting = {
+  fileNameWithoutExtension,
+  normalizeBasePath,
+  isPathInConfigDirectories,
+};

package/src/filesystem/filesystem.ts

@@ -0,0 +1,21 @@
+import type { ConfigItems } from "../config/repository";
+
+export interface FileSystemAdapter {
+  loadConfigItems(basePath: string): ConfigItems;
+}
+
+export class FileSystem {
+  protected adapter: FileSystemAdapter;
+
+  constructor(adapter: FileSystemAdapter) {
+    this.adapter = adapter;
+  }
+
+  setAdapter(adapter: FileSystemAdapter): void {
+    this.adapter = adapter;
+  }
+
+  loadConfigItems(basePath: string): ConfigItems {
+    return this.adapter.loadConfigItems(basePath);
+  }
+}