@raubjo/architect-core 0.1.0 → 0.1.1

package/src/foundation/application.ts

@@ -1,207 +1,237 @@
-import CacheManager from "../cache/manager";
-import { Container } from "inversify";
-import appConfig from "../config/app";
-import { cloneConfigItems } from "../config/clone";
-import { registerGlobalEnv } from "../config/env";
-import ConfigRepository, { type ConfigItems } from "../config/repository";
-import { FileSystem } from "../filesystem/filesystem";
-import LocalAdapter, { __localAdapterTesting } from "../filesystem/adapters/local";
-import ReactRenderer from "../rendering/adapters/react";
-import type { RendererAdapter, RootComponent } from "../rendering/renderer";
-import StorageManager from "../storage/manager";
+import CacheManager from "@/cache/manager";
+import { cloneConfigItems } from "@/config/clone";
+import { registerGlobalEnv } from "@/config/env";
+import ConfigRepository, { type ConfigItems } from "@/config/repository";
+import type {
+    ContainerContract,
+    ContainerIdentifier,
+} from "@/container/contract";
+import {
+    createRuntimeContainer,
+    mergeContainerRuntimeOptions,
+    type ContainerRuntimeOptions,
+} from "@/container/runtime";
+import type Contract from "@/renderers/contract";
+import type { RootComponent } from "@/renderers/contract";
+import StorageManager from "@/storage/manager";
 import ServiceProvider, {
-  type Cleanup,
-  type ServiceProviderContext,
-} from "../support/service-provider";
-import { registerGlobalStr } from "../support/str";
-import Facade from "../support/facades/facade";
+    type Cleanup,
+    type ServiceProviderContext,
+} from "@/support/service-provider";
+import { registerGlobalStr } from "@/support/str";
+import Facade from "@/support/facades/facade";
 
 type StartupHandler = (context: ServiceProviderContext) => void | Cleanup;
 type ServiceRegistrar = (context: ServiceProviderContext) => void | Cleanup;
 
+export type ApplicationConfigureOptions = {
+    basePath?: string;
+    container?: ContainerRuntimeOptions;
+    config?: ConfigItems;
+};
+
+type ApplicationResolvedOptions = {
+    basePath: string;
+    container: ReturnType<typeof mergeContainerRuntimeOptions>;
+    config: ConfigItems;
+};
+
 registerGlobalEnv();
 registerGlobalStr();
 
-export const __applicationTesting = {
-  ...__localAdapterTesting,
-};
+function mergeConfigureOptions(
+    options: ApplicationConfigureOptions = {},
+): ApplicationResolvedOptions {
+    return {
+        basePath: options.basePath ?? "./",
+        container: mergeContainerRuntimeOptions(options.container),
+        config: options.config ?? {},
+    };
+}
 
 export class Application {
-  protected static container: Container | null = null;
-  protected static configCache = new Map<string, ConfigItems>();
-  protected static fileSystem = new FileSystem(new LocalAdapter());
-
-  protected providers: ServiceProvider[];
-  protected serviceRegistrars: ServiceRegistrar[];
-  protected startupHandlers: StartupHandler[];
-  protected rootElementId: string;
-  protected RootComponent: RootComponent | null;
-  protected renderer: RendererAdapter | null;
-  protected basePath: string;
-
-  constructor(basePath = "./") {
-    this.basePath = basePath;
-    this.providers = this.getDefaultProviders();
-    this.serviceRegistrars = [];
-    this.startupHandlers = [];
-    this.rootElementId = "root";
-    this.RootComponent = null;
-    this.renderer = null;
-  }
-
-  protected getDefaultProviders(): ServiceProvider[] {
-    return [];
-  }
-
-  protected static getCachedConfigItems(basePath: string): ConfigItems {
-    const cacheKey = __localAdapterTesting.normalizeBasePath(basePath) || ".";
-
-    if (!Application.configCache.has(cacheKey)) {
-      const loaded = {
-        app: appConfig,
-        ...Application.fileSystem.loadConfigItems(basePath),
-      };
-      Application.configCache.set(cacheKey, loaded);
+    protected static container: ContainerContract | null = null;
+
+    protected providers: ServiceProvider[];
+    protected serviceRegistrars: ServiceRegistrar[];
+    protected startupHandlers: StartupHandler[];
+    protected rootElementId: string;
+    protected RootComponent: RootComponent | null;
+    protected renderer: Contract | null;
+    protected options: ApplicationResolvedOptions;
+
+    constructor(options: ApplicationResolvedOptions) {
+        this.options = options;
+        this.providers = this.getDefaultProviders();
+        this.serviceRegistrars = [];
+        this.startupHandlers = [];
+        this.rootElementId = "root";
+        this.RootComponent = null;
+        this.renderer = null;
     }
 
-    // Give each application instance its own mutable repository data.
-    return cloneConfigItems(Application.configCache.get(cacheKey) as ConfigItems);
-  }
-
-  static clearConfigCache(basePath?: string): void {
-    if (typeof basePath === "string") {
-      const cacheKey = __localAdapterTesting.normalizeBasePath(basePath) || ".";
-      Application.configCache.delete(cacheKey);
-      return;
+    protected getDefaultProviders(): ServiceProvider[] {
+        return [];
     }
 
-    Application.configCache.clear();
-  }
+    protected getConfigItems(): ConfigItems {
+        // Give each application instance its own mutable repository data.
+        return cloneConfigItems(this.options.config);
+    }
 
-  static configure(basePath = "./") {
-    return new Application(basePath);
-  }
+    static clearConfigCache(_basePath?: string): void {}
+
+    static configure(basePath?: string): Application;
+    static configure(options?: ApplicationConfigureOptions): Application;
+    static configure(
+        basePathOrOptions: string | ApplicationConfigureOptions = "./",
+    ) {
+        if (typeof basePathOrOptions === "string") {
+            return new Application(
+                mergeConfigureOptions({ basePath: basePathOrOptions }),
+            );
+        }
 
-  static make<T>(identifier: Parameters<Container["get"]>[0]): T {
-    if (!Application.container) {
-      throw new Error("Application container is not available. Call run() first.");
+        return new Application(mergeConfigureOptions(basePathOrOptions));
     }
 
-    return Application.container.get<T>(identifier);
-  }
-
-  withProviders(providers: ServiceProvider[]) {
-    this.providers.push(...providers);
-    return this;
-  }
-
-  withServices(registerServices: ServiceRegistrar) {
-    this.serviceRegistrars.push(registerServices);
-    return this;
-  }
-
-  withStartup(startupHandler: StartupHandler) {
-    this.startupHandlers.push(startupHandler);
-    return this;
-  }
-
-  withRoot(RootComponent: RootComponent, options: { rootElementId?: string } = {}) {
-    this.RootComponent = RootComponent;
-    this.rootElementId = options.rootElementId ?? this.rootElementId;
-    return this;
-  }
-
-  withRenderer(renderer: RendererAdapter) {
-    this.renderer = renderer;
-    return this;
-  }
-
-  run() {
-    const container = new Container({ defaultScope: "Singleton" });
-    Application.container = container;
-    Facade.clearResolvedInstances();
-    const context = { container };
-    const cleanupTasks: Cleanup[] = [];
-    const configRepository = new ConfigRepository(
-      Application.getCachedConfigItems(this.basePath),
-    );
-    const storageManager = StorageManager.fromConfig(configRepository);
-    const cacheManager = CacheManager.fromConfig(configRepository);
-
-    container.bind("config").toConstantValue(configRepository);
-    container.bind(ConfigRepository).toConstantValue(configRepository);
-    container.bind("storage").toConstantValue(storageManager);
-    container.bind(StorageManager).toConstantValue(storageManager);
-    container.bind("cache").toConstantValue(cacheManager);
-    container.bind(CacheManager).toConstantValue(cacheManager);
-
-    for (const provider of this.providers) {
-      if (typeof provider.register === "function") {
-        const cleanup = provider.register(context);
-        if (typeof cleanup === "function") {
-          cleanupTasks.push(cleanup);
+    static make<T>(identifier: ContainerIdentifier<T>): T {
+        if (!Application.container) {
+            throw new Error(
+                "Application container is not available. Call run() first.",
+            );
         }
-      }
+
+        return Application.container.make<T>(identifier);
     }
 
-    for (const registerServices of this.serviceRegistrars) {
-      const cleanup = registerServices(context);
-      if (typeof cleanup === "function") {
-        cleanupTasks.push(cleanup);
-      }
+    withProviders(providers: ServiceProvider[]) {
+        this.providers.push(...providers);
+        return this;
     }
 
-    for (const provider of this.providers) {
-      if (typeof provider.boot === "function") {
-        const cleanup = provider.boot(context);
-        if (typeof cleanup === "function") {
-          cleanupTasks.push(cleanup);
-        }
-      }
+    withServices(registerServices: ServiceRegistrar) {
+        this.serviceRegistrars.push(registerServices);
+        return this;
     }
 
-    for (const startupHandler of this.startupHandlers) {
-      const cleanup = startupHandler(context);
-      if (typeof cleanup === "function") {
-        cleanupTasks.push(cleanup);
-      }
+    withStartup(startupHandler: StartupHandler) {
+        this.startupHandlers.push(startupHandler);
+        return this;
     }
 
-    let rendererCleanup: Cleanup = () => {};
-    if (this.renderer) {
-      if (!this.RootComponent) {
-        throw new Error("Root component is required when using a custom renderer.");
-      }
-      rendererCleanup = this.renderer.render({
-        ...context,
-        RootComponent: this.RootComponent,
-        rootElementId: this.rootElementId,
-      }) ?? rendererCleanup;
-    } else if (this.RootComponent) {
-      rendererCleanup = new ReactRenderer().render({
-        ...context,
-        RootComponent: this.RootComponent,
-        rootElementId: this.rootElementId,
-      });
+    withRoot(
+        RootComponent: RootComponent,
+        options: { rootElementId?: string } = {},
+    ) {
+        this.RootComponent = RootComponent;
+        this.rootElementId = options.rootElementId ?? this.rootElementId;
+        return this;
     }
 
-    const stop: Cleanup = () => {
-      rendererCleanup();
-      for (const cleanup of cleanupTasks.reverse()) {
-        cleanup();
-      }
-      Facade.clearResolvedInstances();
-      container.unbindAll();
-      if (Application.container === container) {
-        Application.container = null;
-      }
-    };
+    withRenderer(renderer: Contract) {
+        this.renderer = renderer;
+        return this;
+    }
 
-    window.addEventListener("beforeunload", stop, { once: true });
+    protected createContainer(): ContainerContract {
+        return createRuntimeContainer(this.options.container);
+    }
 
-    return {
-      container,
-      stop,
-    };
-  }
+    run() {
+        const container = this.createContainer();
+
+        Application.container = container;
+
+        Facade.clearResolvedInstances();
+
+        const context = { container };
+        const cleanupTasks: Cleanup[] = [];
+        const configRepository = new ConfigRepository(this.getConfigItems());
+        const storageManager = StorageManager.fromConfig(configRepository);
+        const cacheManager = CacheManager.fromConfig(configRepository);
+
+        container.instance("config", configRepository);
+        container.instance(ConfigRepository, configRepository);
+        container.instance("storage", storageManager);
+        container.instance(StorageManager, storageManager);
+        container.instance("cache", cacheManager);
+        container.instance(CacheManager, cacheManager);
+
+        for (const provider of this.providers) {
+            if (typeof provider.register === "function") {
+                const cleanup = provider.register(context);
+                if (typeof cleanup === "function") {
+                    cleanupTasks.push(cleanup);
+                }
+            }
+        }
+
+        for (const registerServices of this.serviceRegistrars) {
+            const cleanup = registerServices(context);
+            if (typeof cleanup === "function") {
+                cleanupTasks.push(cleanup);
+            }
+        }
+
+        for (const provider of this.providers) {
+            if (typeof provider.boot === "function") {
+                const cleanup = provider.boot(context);
+                if (typeof cleanup === "function") {
+                    cleanupTasks.push(cleanup);
+                }
+            }
+        }
+
+        for (const startupHandler of this.startupHandlers) {
+            const cleanup = startupHandler(context);
+            if (typeof cleanup === "function") {
+                cleanupTasks.push(cleanup);
+            }
+        }
+
+        let rendererCleanup: Cleanup = () => {};
+
+        if (this.renderer) {
+            if (!this.RootComponent) {
+                throw new Error(
+                    "Root component is required when using a custom renderer.",
+                );
+            }
+
+            rendererCleanup =
+                this.renderer.render({
+                    ...context,
+                    RootComponent: this.RootComponent,
+                    rootElementId: this.rootElementId,
+                }) ?? rendererCleanup;
+        } else if (this.RootComponent) {
+            throw new Error(
+                "Renderer is required when root component is set. Install a renderer feature (react/solid/svelte/vue) and call withRenderer(...).",
+            );
+        }
+
+        const stop: Cleanup = () => {
+            rendererCleanup();
+
+            for (const cleanup of cleanupTasks.reverse()) {
+                cleanup();
+            }
+
+            Facade.clearResolvedInstances();
+
+            container.flush();
+
+            if (Application.container === container) {
+                Application.container = null;
+            }
+        };
+
+        window.addEventListener("beforeunload", stop, { once: true });
+
+        return {
+            container,
+            stop,
+        };
+    }
 }

package/src/foundation/application_test.helpers.ts

@@ -0,0 +1,31 @@
+import {
+    mergeContainerRuntimeOptions,
+    packageJsonHasDependency,
+    readContainerFactoryRegistry,
+    readPackageJsonCandidates,
+    type ContainerRuntimeOptions,
+} from "@/container/runtime";
+import type { ConfigItems } from "@/config/repository";
+import { localAdapterTestingHelpers } from "@/filesystem/adapters/local_test.helpers";
+
+type ApplicationConfigureOptions = {
+    basePath?: string;
+    container?: ContainerRuntimeOptions;
+    config?: ConfigItems;
+};
+
+function mergeConfigureOptions(options: ApplicationConfigureOptions = {}) {
+    return {
+        basePath: options.basePath ?? "./",
+        container: mergeContainerRuntimeOptions(options.container),
+        config: options.config ?? {},
+    };
+}
+
+export const applicationTestingHelpers = {
+    ...localAdapterTestingHelpers,
+    mergeConfigureOptions,
+    readPackageJsonCandidates,
+    packageJsonHasDependency,
+    readContainerFactoryRegistry,
+};

package/src/index.ts

@@ -1,18 +1,25 @@
 /// <reference path="./config/env.global.d.ts" />
 
 export { Application } from "./foundation/application";
+export type { ApplicationConfigureOptions } from "./foundation/application";
+export { default as BuiltinContainer } from "./container/adapters/builtin";
+export { inject as injectDependency } from "./container/adapters/builtin";
+export type {
+  ContainerContract,
+  ContainerIdentifier,
+  ContainerFactory,
+  ContainerClass,
+  ContainerConcrete,
+} from "./container/contract";
 export { default as ServiceProvider } from "./support/service-provider";
 export { DeferrableServiceProvider } from "./support/service-provider";
 export type { Cleanup, ServiceProviderContext } from "./support/service-provider";
-export { default as ConfigServiceProvider } from "./support/providers/config-service-provider";
 
-export { ApplicationProvider, useService } from "./runtimes/react";
 export type {
-  RendererAdapter,
+  default as Contract,
   RendererContext,
   RootComponent,
-} from "./rendering/renderer";
-export { default as ReactRenderer } from "./rendering/adapters/react";
+} from "./renderers/contract";
 export { default as ConfigRepository } from "./config/repository";
 export { env } from "./config/env";
 export { default as Str } from "./support/str";
@@ -25,9 +32,11 @@ export { default as Cache } from "./support/facades/cache";
 export { default as StorageManager } from "./storage/manager";
 export { default as StorageFacade } from "./support/facades/storage";
 export { default as Storage } from "./support/facades/storage";
-export type { StorageAdapter } from "./storage/storage";
+export type { Adapter as StorageAdapter } from "./storage/adapters/contract";
 export { default as MemoryStorageAdapter } from "./storage/adapters/memory";
 export { default as LocalStorageAdapter } from "./storage/adapters/local-storage";
 export { default as IndexedDbAdapter } from "./storage/adapters/indexed-db";
 export { FileSystem } from "./filesystem/filesystem";
 export { default as LocalAdapter } from "./filesystem/adapters/local";
+export { default as SvelteRenderer } from "./renderers/adapters/svelte";
+export { default as VueRenderer } from "./renderers/adapters/vue";

package/src/react.ts

@@ -0,0 +1,2 @@
+export { ApplicationProvider, useService } from "./runtimes/react";
+export { default as Renderer } from "./renderers/adapters/react";

package/src/renderers/adapters/react.tsx

@@ -0,0 +1,35 @@
+import ReactDOM from "react-dom/client";
+import { createElement } from "react";
+import type { ReactElement } from "react";
+import { ApplicationProvider } from "../../runtimes/react";
+import type Contract from "../contract";
+import type { RendererContext } from "../contract";
+import type { Cleanup } from "../../support/service-provider";
+
+type ReactRootComponent = () => ReactElement | null;
+
+export default class ReactRenderer implements Contract {
+    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 as ReactRootComponent),
+            ),
+        );
+
+        return () => root.unmount();
+    }
+}

package/src/renderers/adapters/solid.tsx

@@ -0,0 +1,32 @@
+import { render } from "solid-js/web";
+import { createComponent, type JSX } from "solid-js";
+import type { Cleanup } from "../../support/service-provider";
+import { ApplicationProvider } from "../../runtimes/solid";
+import type Contract from "../contract";
+import type { RendererContext } from "../contract";
+
+type SolidRootComponent = () => JSX.Element;
+
+export default class SolidRenderer implements Contract {
+    constructor() {}
+
+    render({
+        RootComponent,
+        container,
+        rootElementId,
+    }: RendererContext): Cleanup {
+        const mountNode = document.getElementById(rootElementId);
+        if (!mountNode) {
+            throw new Error(`Missing mount node #${rootElementId}.`);
+        }
+
+        return render(
+            () =>
+                createComponent(ApplicationProvider, {
+                    container,
+                    children: () => (RootComponent as SolidRootComponent)(),
+                }),
+            mountNode,
+        );
+    }
+}

package/src/renderers/adapters/svelte.ts

@@ -0,0 +1,44 @@
+import type { Cleanup } from "../../support/service-provider";
+import type Contract from "../contract";
+import type { RendererContext } from "../contract";
+
+type SvelteComponentInstance = {
+    $destroy?: () => void;
+    destroy?: () => void;
+};
+
+type SvelteComponentConstructor = new (options: {
+    target: Element;
+    props?: Record<string, unknown>;
+}) => SvelteComponentInstance;
+
+export default class SvelteRenderer implements Contract {
+    constructor() {}
+
+    render({
+        RootComponent,
+        container,
+        rootElementId,
+    }: RendererContext): Cleanup {
+        const mountNode = document.getElementById(rootElementId);
+        if (!mountNode) {
+            throw new Error(`Missing mount node #${rootElementId}.`);
+        }
+
+        const Component = RootComponent as SvelteComponentConstructor;
+        const instance = new Component({
+            target: mountNode,
+            props: { container },
+        });
+
+        return () => {
+            if (typeof instance.$destroy === "function") {
+                instance.$destroy();
+                return;
+            }
+            if (typeof instance.destroy === "function") {
+                instance.destroy();
+            }
+        };
+    }
+}

package/src/renderers/adapters/vue.ts

@@ -0,0 +1,28 @@
+import { createApp, type Component } from "vue";
+import type { Cleanup } from "../../support/service-provider";
+import { containerKey } from "../../runtimes/vue";
+import type Contract from "../contract";
+import type { RendererContext } from "../contract";
+
+type VueRootComponent = Component;
+
+export default class VueRenderer implements Contract {
+    constructor() {}
+
+    render({
+        RootComponent,
+        container,
+        rootElementId,
+    }: RendererContext): Cleanup {
+        const mountNode = document.getElementById(rootElementId);
+        if (!mountNode) {
+            throw new Error(`Missing mount node #${rootElementId}.`);
+        }
+
+        const app = createApp(RootComponent as VueRootComponent);
+        app.provide(containerKey, container);
+        app.mount(mountNode);
+
+        return () => app.unmount();
+    }
+}

package/src/renderers/contract.ts

@@ -0,0 +1,15 @@
+import type {
+    Cleanup,
+    ServiceProviderContext,
+} from "../support/service-provider";
+
+export type RootComponent = unknown;
+
+export type RendererContext = ServiceProviderContext & {
+    RootComponent: RootComponent;
+    rootElementId: string;
+};
+
+export default interface Contract {
+    render(context: RendererContext): void | Cleanup;
+}