react-obsidian 3.0.0-alpha.6 → 3.0.0-alpha.8

package/src/graph/registry/GraphRegistry.ts

@@ -5,6 +5,8 @@ import GraphMiddlewareChain from './GraphMiddlewareChain';
 import { ObtainLifecycleBoundGraphException } from './ObtainLifecycleBoundGraphException';
 import { getMetadata } from '../../utils/reflect';
 import { getGlobal } from '../../utils/getGlobal';
+import { isString } from '../../utils/isString';
+import referenceCounter from '../../ReferenceCounter';
 
 export class GraphRegistry {
   private readonly constructorToInstance = new Map<Constructable<Graph>, Set<Graph>>();
@@ -14,16 +16,30 @@ export class GraphRegistry {
   private readonly nameToInstance = new Map<string, Graph>();
   private readonly graphToSubgraphs = new Map<Constructable<Graph>, Set<Constructable<Graph>>>();
   private readonly graphMiddlewares = new GraphMiddlewareChain();
+  private readonly keyToGenerator = new Map<string, () => Constructable<Graph>>();
+  private readonly keyToGraph = new Map<string, Constructable<Graph>>();
+  private readonly onClearListeners = new Map<Graph, Set<() => void>>();
 
   register(constructor: Constructable<Graph>, subgraphs: Constructable<Graph>[] = []) {
     this.graphToSubgraphs.set(constructor, new Set(subgraphs));
   }
 
-  ensureRegistered(graph: Graph) {
+  registerGraphGenerator(key: string, generator: () => Constructable<Graph>) {
+    if (this.keyToGenerator.has(key)) throw new Error(`Attempted to register a graph generator for key "${key}" that is already registered.`);
+    this.keyToGenerator.set(key, generator);
+  }
+
+  ensureRegistered(keyOrGraph: string | Graph) {
+    if (isString(keyOrGraph)) return;
+    const graph = keyOrGraph;
     if (this.instanceToConstructor.get(graph)) return;
     this.set(graph.constructor as any, graph);
   }
 
+  public isInstantiated(G: Constructable<Graph>): boolean {
+    return (this.constructorToInstance.get(G)?.size ?? 0) > 0;
+  }
+
   getSubgraphs(graph: Graph): Graph[] {
     const Graph = this.instanceToConstructor.get(graph)!;
     const subgraphs = this.graphToSubgraphs.get(Graph) ?? new Set();
@@ -35,24 +51,85 @@ export class GraphRegistry {
   }
 
   resolve<T extends Graph>(
-    Graph: Constructable<T>,
+    keyOrGraph: string | Constructable<T>,
     source: 'lifecycleOwner' | 'classInjection' | 'serviceLocator' = 'lifecycleOwner',
     props: any = undefined,
     injectionToken?: string,
   ): T {
+    const Graph = isString(keyOrGraph) ?
+      this.getGraphConstructorByKey<T>(keyOrGraph) :
+      keyOrGraph;
     if ((this.isSingleton(Graph) || this.isBoundToReactLifecycle(Graph)) && this.has(Graph, injectionToken)) {
-      return this.isComponentScopedLifecycleBound(Graph)
-        ? this.getByInjectionToken(Graph, injectionToken)
-        : this.getFirst(Graph);
+      return this.isComponentScopedLifecycleBound(Graph) ?
+        this.getByInjectionToken(Graph, injectionToken) :
+        this.getFirst(Graph);
     }
     if (this.isBoundToReactLifecycle(Graph) && source !== 'lifecycleOwner') {
       throw new ObtainLifecycleBoundGraphException(Graph);
     }
     const graph = this.graphMiddlewares.resolve(Graph, props);
     this.set(Graph, graph, injectionToken);
+    this.instantiateCustomScopedSubgraphs(graph, props);
     return graph as T;
   }
 
+  private instantiateCustomScopedSubgraphs(graph: Graph, props: any) {
+    this.assertInstantiatingCustomScopedSubgraphFromSameScope(graph);
+    if (!this.isCustomScopedLifecycleBound(this.instanceToConstructor.get(graph)!)) return;
+    const customScope = getMetadata(this.instanceToConstructor.get(graph)!, 'lifecycleScope');
+    const subgraphs = this.getSubgraphsConstructors(graph);
+    const sameScopeSubgraphs = subgraphs.filter(
+      subgraph => getMetadata(subgraph, 'lifecycleScope') === customScope,
+    );
+    const instantiatedSubgraphs = sameScopeSubgraphs.map(
+      (subgraph) => {
+        return this.resolve(subgraph, 'lifecycleOwner', props);
+      },
+    );
+    instantiatedSubgraphs.forEach(subgraph => referenceCounter.retain(subgraph));
+    this.registerOnClearListener(graph, () => {
+      instantiatedSubgraphs.forEach(subgraph => referenceCounter.release(subgraph, () => this.clear(subgraph)));
+    });
+  }
+
+  private assertInstantiatingCustomScopedSubgraphFromSameScope(graph: Graph) {
+    const graphScope = getMetadata(this.instanceToConstructor.get(graph)!, 'lifecycleScope');
+    const subgraphs = this.getSubgraphsConstructors(graph);
+    subgraphs.forEach((subgraph) => {
+      const subgraphScope = getMetadata(subgraph, 'lifecycleScope');
+      if (
+        !this.isInstantiated(subgraph)
+        && this.isCustomScopedLifecycleBound(subgraph)
+        && graphScope !== subgraphScope
+      ) {
+        throw new Error(`Cannot instantiate the scoped graph '${subgraph.name}' as a subgraph of '${graph.constructor.name}' because the scopes do not match. ${graphScope} !== ${subgraphScope}`);
+      }
+    });
+  }
+
+  private getSubgraphsConstructors(graph: Graph | Constructable<Graph>): Constructable<Graph>[] {
+    const Graph = typeof graph === 'function' ? graph : this.instanceToConstructor.get(graph)!;
+    const directSubgraphs = Array.from(this.graphToSubgraphs.get(Graph) ?? new Set<Constructable<Graph>>());
+    if (directSubgraphs.length === 0) return [];
+    return [
+      ...directSubgraphs,
+      ...new Set(
+        directSubgraphs
+          .map(subgraph => this.getSubgraphsConstructors(subgraph))
+          .flat(),
+      ),
+    ];
+  }
+
+  private getGraphConstructorByKey<T extends Graph>(key: string): Constructable<T> {
+    if (this.keyToGraph.has(key)) return this.keyToGraph.get(key) as Constructable<T>;
+    const generator = this.keyToGenerator.get(key);
+    if (!generator) throw new Error(`Attempted to resolve a graph by key "${key}" that is not registered. Did you forget to call Obsidian.registerGraph?`);
+    const constructor = generator();
+    this.keyToGraph.set(key, constructor);
+    return constructor as Constructable<T>;
+  }
+
   private has(Graph: Constructable<Graph>, injectionToken?: string): boolean {
     const instances = this.constructorToInstance.get(Graph);
     if (!instances) return false;
@@ -102,6 +179,11 @@ export class GraphRegistry {
     return getMetadata(Graph, 'lifecycleScope') === 'component';
   }
 
+  private isCustomScopedLifecycleBound(Graph: Constructable<Graph>): boolean {
+    const scope = getMetadata(Graph, 'lifecycleScope');
+    return typeof scope === 'string' && scope !== 'component' && scope !== 'feature';
+  }
+
   clearGraphAfterItWasMockedInTests(graphName: string) {
     const graphNames = this.nameToInstance.keys();
     for (const name of graphNames) {
@@ -119,6 +201,7 @@ export class GraphRegistry {
           this.injectionTokenToInstance.delete(token);
           this.instanceToInjectionToken.delete(graph);
         }
+        this.invokeOnClearListeners(graph);
       }
     }
   }
@@ -134,6 +217,32 @@ export class GraphRegistry {
       this.injectionTokenToInstance.delete(token);
       this.instanceToInjectionToken.delete(graph);
     }
+
+    this.clearGraphsRegisteredByKey(Graph);
+    this.invokeOnClearListeners(graph);
+  }
+
+  private registerOnClearListener(graph: Graph, callback: () => void) {
+    const listeners = this.onClearListeners.get(graph) ?? new Set();
+    listeners.add(callback);
+    this.onClearListeners.set(graph, listeners);
+  }
+
+  private invokeOnClearListeners(graph: Graph) {
+    const listeners = this.onClearListeners.get(graph);
+    if (!listeners) return;
+    listeners.forEach(listener => listener());
+    this.onClearListeners.delete(graph);
+  }
+
+  private clearGraphsRegisteredByKey(Graph: Constructable<Graph>) {
+    [...this.keyToGraph.keys()]
+      .map(key => [key, this.keyToGraph.get(key)!] as [string, Constructable<Graph>])
+      .filter(([_, $Graph]) => $Graph === Graph)
+      .forEach(([key, _]) => {
+        this.keyToGraph.delete(key);
+        this.keyToGenerator.delete(key);
+      });
   }
 
   addGraphMiddleware(middleware: Middleware<Graph>) {
@@ -150,11 +259,11 @@ export class GraphRegistry {
     this.nameToInstance.clear();
     this.injectionTokenToInstance.clear();
     this.instanceToInjectionToken.clear();
+    this.keyToGenerator.clear();
+    this.keyToGraph.clear();
   }
 }
 
-// // @ts-expect-error - workaround an issue in jest tests where the registry was created multiple times
-const _global = getGlobal();
-_global.graphRegistry = _global.graphRegistry || new GraphRegistry();
-// // @ts-expect-error - see above
-export default _global.graphRegistry as GraphRegistry;
+const globalObject = getGlobal();
+globalObject.graphRegistry = globalObject.graphRegistry || new GraphRegistry();
+export default globalObject.graphRegistry as GraphRegistry;

package/src/injectors/class/ClassInjector.ts

@@ -12,14 +12,14 @@ export default class ClassInjector {
     private injectionMetadata: InjectionMetadata = new InjectionMetadata(),
   ) {}
 
-  inject(Graph: Constructable<Graph>) {
+  inject(keyOrGraph: string | Constructable<Graph>) {
     return (Target: Constructable<any>) => {
-      return new Proxy(Target, this.createProxyHandler(Graph, this.graphRegistry, this.injectionMetadata));
+      return new Proxy(Target, this.createProxyHandler(keyOrGraph, this.graphRegistry, this.injectionMetadata));
     };
   }
 
   private createProxyHandler(
-    Graph: Constructable<Graph>,
+    keyOrGraph: string | Constructable<Graph>,
     graphRegistry: GraphRegistry,
     injectionMetadata: InjectionMetadata,
   ): ProxyHandler<any> {
@@ -27,14 +27,14 @@ export default class ClassInjector {
       construct(target: any, args: any[], newTarget: Function): any {
         const isReactClassComponent = target.prototype?.isReactComponent;
         const source = isReactClassComponent ? 'lifecycleOwner' : 'classInjection';
-        const graph = graphRegistry.resolve(Graph, source, args.length > 0 ? args[0] : undefined);
+        const graph = graphRegistry.resolve(keyOrGraph, source, args.length > 0 ? args[0] : undefined);
         if (isReactClassComponent) {
           referenceCounter.retain(graph);
         }
         defineMetadata(target, GRAPH_INSTANCE_NAME_KEY, graph.name);
-        const argsToInject = this.injectConstructorArgs(args, graph, target);
+
         graph.onBind(target);
-        const createdObject = Reflect.construct(target, argsToInject, newTarget);
+        const createdObject = Reflect.construct(target, args, newTarget);
         this.injectProperties(target, createdObject, graph);
         const originalComponentWillUnmount: () => void | undefined = createdObject.componentWillUnmount;
         createdObject.componentWillUnmount = () => {
@@ -44,14 +44,6 @@ export default class ClassInjector {
         return createdObject;
       }
 
-      private injectConstructorArgs(args: any[], graph: Graph, target: any): any[] {
-        const argsToInject = injectionMetadata.getConstructorArgsToInject(target);
-        if (!argsToInject.hasArgs()) return args;
-        return [...args, ...new Array(Math.abs(args.length - argsToInject.size()))].map((value, idx): any => {
-          return value ?? graph.retrieve(argsToInject.getProperty(idx));
-        });
-      }
-
       private injectProperties(target: any, createdObject: any, graph: Graph) {
         injectionMetadata.getPropertiesToInject(target).forEach((key) => {
           Reflect.set(createdObject, key, graph.retrieve(key));

package/src/injectors/class/LateInjector.ts

@@ -1,3 +1,4 @@
+import { isString } from 'lodash';
 import { ObjectGraph } from '../../graph/ObjectGraph';
 import graphRegistry from '../../graph/registry/GraphRegistry';
 import { getMetadata } from '../../utils/reflect';
@@ -6,16 +7,22 @@ import InjectionMetadata from './InjectionMetadata';
 export const GRAPH_INSTANCE_NAME_KEY = 'GRAPH_INSTANCE_NAME';
 
 class LateInjector<T extends object> {
-  inject(target: T, sourceGraph?: ObjectGraph): T {
-    if (sourceGraph) graphRegistry.ensureRegistered(sourceGraph);
+  inject(target: T, keyOrGraph?: string | ObjectGraph): T {
+    if (keyOrGraph) graphRegistry.ensureRegistered(keyOrGraph);
     const injectionMetadata = new InjectionMetadata();
-    const graph = sourceGraph ?? this.getGraphInstance(target);
+    const graph = this.getGraph(target, keyOrGraph);
     injectionMetadata.getLatePropertiesToInject(target.constructor).forEach((key) => {
       Reflect.set(target, key, graph.retrieve(key));
     });
     return target;
   }
 
+  private getGraph(target: T, keyOrGraph?: string | ObjectGraph) {
+    if (keyOrGraph instanceof ObjectGraph) return keyOrGraph;
+    if (isString(keyOrGraph)) return graphRegistry.resolve(keyOrGraph, 'classInjection');
+    return this.getGraphInstance(target);
+  }
+
   private getGraphInstance(target: T) {
     const graphInstanceName = getMetadata(target.constructor, GRAPH_INSTANCE_NAME_KEY);
     return graphRegistry.getGraphInstance(graphInstanceName);

package/src/injectors/components/ComponentInjector.tsx

@@ -11,24 +11,24 @@ import { useInjectionToken } from './useInjectionToken';
 export default class ComponentInjector {
   inject<P>(
     Target: React.FunctionComponent<P>,
-    Graph: Constructable<ObjectGraph>,
+    keyOrGraph: string | Constructable<ObjectGraph>,
   ): React.FunctionComponent<Partial<P>> {
-    const Wrapped = this.wrapComponent(Target, Graph);
+    const Wrapped = this.wrapComponent(Target, keyOrGraph);
     hoistNonReactStatics(Wrapped, Target);
     return Wrapped;
   }
 
   private wrapComponent<P>(
     InjectionCandidate: React.FunctionComponent<P>,
-    Graph: Constructable<ObjectGraph>,
+    keyOrGraph: string | Constructable<ObjectGraph>,
   ): React.FunctionComponent<Partial<P>> {
     const isMemoized = isMemoizedComponent(InjectionCandidate);
     const Target = isMemoized ? InjectionCandidate.type : InjectionCandidate;
     const compare = isMemoized ? InjectionCandidate.compare : undefined;
 
     return genericMemo((passedProps: P) => {
-      const injectionToken = useInjectionToken(Graph);
-      const graph = useGraph<P>(Graph, Target, passedProps, injectionToken);
+      const injectionToken = useInjectionToken(keyOrGraph);
+      const graph = useGraph<P>(keyOrGraph, Target, passedProps, injectionToken);
       const proxiedProps = new PropsInjector(graph).inject(passedProps);
 
       return (

package/src/injectors/components/InjectComponent.ts

@@ -1,6 +1,7 @@
 import React from 'react';
 import { ObjectGraph } from '../../graph/ObjectGraph';
 import { Constructable } from '../../types';
+import { isString } from '../../utils/isString';
 import ComponentInjector from './ComponentInjector';
 
 interface Discriminator {
@@ -14,18 +15,18 @@ export const injectComponent = <OwnProps = Discriminator, InjectedProps = Discri
   (OwnProps extends infer P ? OwnProps extends Discriminator ? P : OwnProps : never) &
   (InjectedProps extends Discriminator ? any : InjectedProps)
   >,
-  Graph: Constructable<ObjectGraph>,
+  keyOrGraph: string | Constructable<ObjectGraph>,
 ) => {
-  assertGraph(Graph, Target);
+  assertGraph(keyOrGraph, Target);
 
-  return componentInjector.inject(Target, Graph) as React.FunctionComponent<
+  return componentInjector.inject(Target, keyOrGraph) as React.FunctionComponent<
     InjectedProps extends Discriminator ?
       OwnProps extends Discriminator ? Partial<OwnProps> : OwnProps :
       OwnProps extends InjectedProps ? Partial<OwnProps> : OwnProps & Partial<InjectedProps>
   >;
 };
-function assertGraph(Graph: Constructable<ObjectGraph<unknown>>, Target: any) {
-  if (!Graph) {
+function assertGraph(keyOrGraph: string | Constructable<ObjectGraph>, Target: any) {
+  if (!isString(keyOrGraph) && !keyOrGraph) {
     throw new Error(
       `injectComponent was called with an undefined Graph.`
       + `This is probably not an issue with Obsidian.`

package/src/injectors/components/useGraph.ts

@@ -5,13 +5,13 @@ import graphRegistry from '../../graph/registry/GraphRegistry';
 import referenceCounter from '../../ReferenceCounter';
 
 export default <P>(
-  Graph: Constructable<ObjectGraph>,
+  keyOrGraph: string | Constructable<ObjectGraph>,
   target: any,
   props?: Partial<P>,
   injectionToken?: string,
 ) => {
   const [graph] = useState(() => {
-    const resolvedGraph = graphRegistry.resolve(Graph, 'lifecycleOwner', props, injectionToken);
+    const resolvedGraph = graphRegistry.resolve(keyOrGraph, 'lifecycleOwner', props, injectionToken);
     resolvedGraph.onBind(target);
     return resolvedGraph;
   });

package/src/injectors/components/useInjectionToken.ts

@@ -2,9 +2,12 @@ import { useContext, useState } from 'react';
 import { GraphContext } from './graphContext';
 import type { Constructable, ObjectGraph } from '../..';
 import { uniqueId } from '../../utils/uniqueId';
+import { isString } from '../../utils/isString';
 
-export const useInjectionToken = (Graph: Constructable<ObjectGraph>) => {
+export const useInjectionToken = (keyOrGraph: string | Constructable<ObjectGraph>) => {
   const ctx = useContext(GraphContext);
-  const [injectionToken] = useState(() => ctx?.injectionToken ?? uniqueId(Graph.name));
+  const [injectionToken] = useState(() => {
+    return ctx?.injectionToken ?? uniqueId(isString(keyOrGraph) ? keyOrGraph : keyOrGraph.name);
+  });
   return injectionToken;
 };

package/src/injectors/hooks/HookInjector.ts

@@ -6,10 +6,10 @@ import { Constructable } from '../../types';
 export default class HookInjector {
   inject<Args, Result>(
     hook: (args: Args) => Result,
-    Graph: Constructable<ObjectGraph>,
+    keyOrGraph: string | Constructable<ObjectGraph>,
   ): (args?: Partial<Args>) => Result {
     return (args?: Partial<Args>): Result => {
-      const graph = useGraph(Graph, hook, args);
+      const graph = useGraph(keyOrGraph, hook, args);
       return hook(new Proxy(args ?? {}, new Injector(graph)));
     };
   }

package/src/injectors/hooks/InjectHook.ts

@@ -11,14 +11,14 @@ const hookInjector = new HookInjector();
 
 export function injectHookWithArguments<Injected, Own, Result = {}>(
   hook: (args: Injected & Own) => Result,
-  Graph: Constructable<ObjectGraph>,
+  keyOrGraph: string | Constructable<ObjectGraph>,
 ): (props: Own & Partial<Injected>) => Result {
-  return hookInjector.inject(hook, Graph) as (props: Own & Partial<Injected>) => Result;
+  return hookInjector.inject(hook, keyOrGraph) as (props: Own & Partial<Injected>) => Result;
 }
 
 export function injectHook<Injected, Result = {}>(
   hook: (args: Injected) => Result,
-  Graph: Constructable<ObjectGraph>,
+  keyOrGraph: string | Constructable<ObjectGraph>,
 ): (props?: Partial<Injected>) => Result {
-  return hookInjector.inject(hook, Graph);
+  return hookInjector.inject(hook, keyOrGraph);
 }

package/src/utils/isString.ts

@@ -0,0 +1,3 @@
+export function isString(value: any): value is string {
+  return typeof value === 'string';
+}

package/src/utils/reflect.ts

@@ -1,4 +1,12 @@
-const metadataStore = new WeakMap();
+import { getGlobal } from './getGlobal';
+
+function getStore(): WeakMap<any, any> {
+  const global = getGlobal();
+  global.__metadataStore = global.__metadataStore || new WeakMap();
+  return global.__metadataStore;
+}
+
+const metadataStore = getStore();
 
 export function defineMetadata(target: any, key: string, value: any) {
   let metadata = metadataStore.get(target);
@@ -15,3 +23,8 @@ export function getMetadata(target: any, key: string) {
   const metadata = metadataStore.get(target);
   return metadata ? metadata[key] : undefined;
 }
+
+export function hasMetadata(target: any, key: string) {
+  const metadata = metadataStore.get(target);
+  return metadata ? metadata[key] !== undefined : false;
+}