react-obsidian 0.0.1

package/src/graph/registry/DefaultGraphResolver.ts

@@ -0,0 +1,9 @@
+import { Constructable } from '@Obsidian';
+import Graph from '../Graph';
+import { GraphMiddleware, ResolveChain } from './GraphMiddleware';
+
+export default class DefaultGraphMiddleware extends GraphMiddleware {
+  resolve<T extends Graph, Props>(_resolveChain: ResolveChain, Graph: Constructable<T>, props?: Props): T {
+    return new Graph(props);
+  }
+}

package/src/graph/registry/GraphMiddleware.ts

@@ -0,0 +1,24 @@
+import { Constructable } from '@Obsidian';
+import Graph from '../Graph';
+
+export abstract class GraphMiddleware {
+  private next!: GraphMiddleware;
+
+  public setNext(next: GraphMiddleware) {
+    this.next = next;
+  }
+
+  public get resolveChain(): ResolveChain {
+    return {
+      proceed: <T extends Graph, Props>(Graph: Constructable<T>, props?: Props): T => {
+        return this.next.resolve(this.next.resolveChain, Graph, props);
+      },
+    };
+  }
+
+  abstract resolve<T extends Graph, Props>(resolveChain: ResolveChain, Graph: Constructable<T>, props?: Props): T;
+}
+
+export interface ResolveChain {
+  proceed<T extends Graph, Props>(Graph: Constructable<T>, props?: Props): T;
+}

package/src/graph/registry/GraphMiddlewareChain.ts

@@ -0,0 +1,31 @@
+import { Constructable } from '@Obsidian';
+import Graph from '../Graph';
+import DefaultGraphMiddleware from './DefaultGraphResolver';
+import { GraphMiddleware } from './GraphMiddleware';
+
+export default class GraphMiddlewareChain {
+  private middlewares: GraphMiddleware[];
+
+  constructor(defaultMiddleware: GraphMiddleware = new DefaultGraphMiddleware()) {
+    this.middlewares = [defaultMiddleware];
+  }
+
+  resolve<T extends Graph>(Graph: Constructable<T>, props?: any): T {
+    return this.middlewares[0].resolve(this.middlewares[0].resolveChain, Graph, props);
+  }
+
+  add(middleware: GraphMiddleware) {
+    this.middlewares.unshift(middleware);
+    this.updateResolveChain();
+  }
+
+  private updateResolveChain() {
+    if (this.middlewares.length > 1) {
+      this.middlewares[0].setNext(this.middlewares[1]);
+    }
+  }
+
+  clear() {
+    this.middlewares = [new DefaultGraphMiddleware()];
+  }
+}

package/src/graph/registry/GraphRegistry.ts

@@ -0,0 +1,70 @@
+import { Constructable, Scope } from '@Obsidian';
+import Graph from '../Graph';
+import { GraphMiddleware } from './GraphMiddleware';
+import GraphMiddlewareChain from './GraphMiddlewareChain';
+
+class GraphRegistry {
+  private readonly scopedGraphs: Record<Scope, Constructable<Graph>> = {};
+  private readonly constructorToInstance = new Map<Constructable<Graph>, Graph>();
+  private readonly instanceToConstructor = new Map<Graph, Constructable<Graph>>();
+  private readonly graphToSubgraphs = new Map<Constructable<Graph>, Set<Constructable<Graph>>>();
+  private graphMiddlewares = new GraphMiddlewareChain();
+
+  register(
+    constructor: Constructable<Graph>,
+    scope: Scope | undefined = undefined,
+    subgraphs: Constructable<Graph>[] = [],
+  ) {
+    if (scope) this.scopedGraphs[scope] = constructor;
+    this.graphToSubgraphs.set(constructor, new Set(subgraphs));
+  }
+
+  has(Graph: Constructable<Graph>) {
+    return this.constructorToInstance.has(Graph);
+  }
+
+  get<T extends Graph>(Graph: Constructable<T>): T {
+    return this.constructorToInstance.get(Graph)! as unknown as T;
+  }
+
+  set(Graph: Constructable<Graph>, graph: Graph) {
+    this.constructorToInstance.set(Graph, graph);
+    this.instanceToConstructor.set(graph, Graph);
+  }
+
+  getSubgraphs(graph: Graph): Graph[] {
+    const Graph = this.instanceToConstructor.get(graph)!;
+    const subgraphs = this.graphToSubgraphs.get(Graph) ?? new Set();
+    return Array.from(subgraphs).map((G) => this.resolve(G));
+  }
+
+  resolve<T extends Graph>(Graph: Constructable<T>, props?: any): T {
+    if (this.has(Graph)) {
+      return this.get(Graph);
+      // const graph: T = this.get(Graph);
+      // const scope = Reflect.getMetadata('scope', Graph);
+      // if (scope) return graph;
+
+      // this.set(Graph, new Graph(props));
+    }
+    const graph = this.graphMiddlewares.resolve(Graph, props);
+    this.set(Graph, graph);
+    return graph;
+  }
+
+  clear(graph: Graph) {
+    const Graph = this.instanceToConstructor.get(graph)!;
+    this.instanceToConstructor.delete(graph);
+    this.constructorToInstance.delete(Graph);
+  }
+
+  addGraphMiddleware(middleware: GraphMiddleware) {
+    this.graphMiddlewares.add(middleware);
+  }
+
+  clearGraphMiddlewares() {
+    this.graphMiddlewares.clear();
+  }
+}
+
+export default new GraphRegistry();

package/src/index.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+import { Constructable } from '@Obsidian';
+import _Graph from './decorators/Graph';
+import _ObjectGraph from './graph/ObjectGraph';
+import _injectHook from './injectHook';
+import ComponentInjector from './injectors/components/ComponentInjector';
+import _Provides from './Provides';
+import { Inject as _Inject, Injectable as _Injectable } from './decorators/injectClass';
+import _obsidian from './Obsidian';
+
+export const Graph = _Graph;
+export const ObjectGraph = _ObjectGraph;
+export const injectHook = _injectHook;
+export const Provides = _Provides;
+export const Injectable = _Injectable;
+export const Inject = _Inject;
+export const Obsidian = new _obsidian();
+
+const componentInjector = new ComponentInjector();
+export const injectComponent = <P> (
+  __Target: React.FunctionComponent<P>,
+  __Graph: Constructable<_ObjectGraph>,
+) => componentInjector.inject(__Target, __Graph);

package/src/injectHook.ts

@@ -0,0 +1,26 @@
+import { Constructable } from '@Obsidian';
+import { useEffect, useState } from 'react';
+import 'reflect-metadata';
+import graphRegistry from './graph/registry/GraphRegistry';
+import ObjectGraph from './graph/ObjectGraph';
+import referenceCounter from './ReferenceCounter';
+
+export default function injectHook<S, T>(target: (args: S) => T, Graph: Constructable<ObjectGraph>) {
+  return (args?: Partial<S>): T => {
+    const [graph] = useState(graphRegistry.resolve(Graph, args));
+    useEffect(() => {
+      referenceCounter.retain(graph);
+      return () => referenceCounter.release(graph, (g) => graphRegistry.clear(g));
+    }, [graph]);
+
+    return target(new Proxy(args ?? {}, new Injector(graph)));
+  };
+}
+
+class Injector implements ProxyHandler<any> {
+  constructor(private graph: ObjectGraph) {}
+
+  get(obj: any, property: string, receiver: any): any {
+    return property in obj ? obj[property] : this.graph.retrieve(property, receiver);
+  }
+}

package/src/injectors/components/ComponentInjector.tsx

@@ -0,0 +1,29 @@
+import React, { useState } from 'react';
+import { Constructable } from '@Obsidian';
+import hoistNonReactStatics from 'hoist-non-react-statics';
+import 'reflect-metadata';
+import ObjectGraph from '../../graph/ObjectGraph';
+import PropsInjector from './PropsInjector';
+import useGraph from './useGraph';
+
+export default class ComponentInjector {
+  inject<P>(
+    Target: React.FunctionComponent<P>,
+    Graph: Constructable<ObjectGraph>,
+  ): React.FunctionComponent<Partial<P>> {
+    const Wrapped = this.wrapComponent(Target, Graph);
+    hoistNonReactStatics(Wrapped, Target);
+    return Wrapped;
+  }
+
+  private wrapComponent<P>(
+    Target: React.FunctionComponent<P>,
+    Graph: Constructable<ObjectGraph>,
+  ): React.FunctionComponent<Partial<P>> {
+    return (passedProps: Partial<P>) => {
+      const graph = useGraph(Graph, passedProps);
+      const [proxiedProps] = useState(new PropsInjector(graph).inject(passedProps));
+      return <>{Target(proxiedProps as unknown as P)}</>;
+    };
+  }
+}

package/src/injectors/components/PropsInjector.ts

@@ -0,0 +1,14 @@
+import ObjectGraph from 'src/graph/ObjectGraph';
+
+export default class PropsInjector<Props> {
+  constructor(private graph: ObjectGraph) {}
+
+  inject(passedProps: Props): Partial<Props> {
+    // eslint-disable-next-line prefer-object-spread
+    return new Proxy(Object.assign({}, passedProps), {
+      get: (target: object, p: string, receiver: any): any => {
+        return p in target ? Reflect.get(target, p, receiver) : this.graph.retrieve(p, receiver);
+      },
+    });
+  }
+}

package/src/injectors/components/useGraph.ts

@@ -0,0 +1,14 @@
+import { Constructable } from '@Obsidian';
+import { useEffect, useState } from 'react';
+import ObjectGraph from 'src/graph/ObjectGraph';
+import graphRegistry from '../../graph/registry/GraphRegistry';
+import referenceCounter from '../../ReferenceCounter';
+
+export default <P>(Graph: Constructable<ObjectGraph>, props: Partial<P>) => {
+  const [graph] = useState(graphRegistry.resolve(Graph, props));
+  useEffect(() => {
+    referenceCounter.retain(graph);
+    return () => referenceCounter.release(graph, (g) => graphRegistry.clear(g));
+  }, [graph]);
+  return graph;
+};

package/testkit/index.ts

@@ -0,0 +1,25 @@
+import { GraphMiddleware, ResolveChain } from '../src/graph/registry/GraphMiddleware';
+import ObjectGraph from '../src/graph/Graph';
+import { Constructable } from '../src/@types/obsidian';
+import { Obsidian } from '../src';
+
+beforeEach(() => {
+  Obsidian.clearGraphMiddlewares();
+});
+
+class Index {
+  mockGraphs(graphNameToGraph: Record<string, Constructable<ObjectGraph>>) {
+    const graphMiddleware = new class extends GraphMiddleware {
+      resolve<T extends ObjectGraph, Props>(resolveChain: ResolveChain, Graph: Constructable<T>, props?: Props) {
+        if (graphNameToGraph[Graph.name]) {
+          const TheGraph = graphNameToGraph[Graph.name];
+          return new TheGraph(props) as unknown as T;
+        }
+        return resolveChain.proceed(Graph, props);
+      }
+    }();
+    Obsidian.addGraphMiddleware(graphMiddleware);
+  }
+}
+
+export default new Index();

package/transformers/babel-plugin-obsidian-provide/helpers/index.ts

@@ -0,0 +1,59 @@
+/* eslint-disable no-param-reassign */
+import { types as t } from '@babel/core';
+import {
+  CallExpression,
+  ClassMethod,
+  Decorator,
+  Identifier,
+  ObjectExpression,
+  ObjectPattern,
+} from '@babel/types';
+import { get } from 'lodash';
+
+export function providerIsNotNamed(decorator: Decorator): boolean {
+  const argument = getDecoratorArgument(decorator);
+  if (t.isObjectExpression(argument)) {
+    return argument.properties.find((p) => {
+      if (t.isObjectProperty(p)) {
+        return t.isIdentifier(p.key) && p.key.name === 'name';
+      }
+      return false;
+    }) === undefined;
+  }
+  return true;
+}
+
+export function addNameToProviderArguments(node: ClassMethod, decorator: Decorator) {
+  const argument = getDecoratorArgument(decorator) ?? t.objectExpression([]);
+  argument.properties.push(t.objectProperty(
+    t.identifier('name'),
+    t.stringLiteral(getMethodName(node)),
+  ));
+  (decorator.expression as CallExpression).arguments = [argument];
+}
+
+export function getDecoratorArgument(decorator: Decorator): ObjectExpression | undefined {
+  if (t.isCallExpression(decorator.expression)) {
+    return decorator.expression.arguments.find((a) => t.isObjectExpression(a)) as ObjectExpression;
+  }
+  return undefined;
+}
+
+export function getMethodName(node: ClassMethod): string {
+  if (t.isIdentifier(node.key)) return node.key.name;
+  throw new Error(`Tried to get class name but encountered unexpected key of type: ${node.key.type}`);
+}
+
+export function getProviderDecorator(decorators: Array<Decorator> | undefined | null): Decorator | undefined {
+  return decorators?.find((decorator) => get(decorator, 'expression.callee.name') === 'Provides');
+}
+
+export function getDecoratorName(decorator?: Decorator): string | undefined {
+  return get(decorator, 'expression.callee.name');
+}
+
+export function paramsToDestructuringAssignment(params: (Identifier | any)[]): ObjectPattern {
+  return t.objectPattern(params
+    .filter((p) => t.isIdentifier(p))
+    .map((p) => t.objectProperty(t.identifier(p.name), t.identifier(p.name))));
+}

package/transformers/babel-plugin-obsidian-provide/index.ts

@@ -0,0 +1,44 @@
+/* eslint-disable no-param-reassign */
+import { ClassMethod, Decorator, Program } from '@babel/types';
+import { NodePath, PluginObj } from '@babel/core';
+import {
+  addNameToProviderArguments,
+  getDecoratorName,
+  getProviderDecorator,
+  paramsToDestructuringAssignment,
+  providerIsNotNamed,
+} from './helpers';
+
+const providerArgumentsTransformer: PluginObj = {
+  visitor: {
+    Program(path: NodePath<Program>) {
+      path.traverse(internalVisitor);
+    },
+  },
+};
+
+const internalVisitor = {
+  ClassMethod: {
+    enter({ node }: NodePath<ClassMethod>) {
+      const decorator = getProviderDecorator(node.decorators);
+      if (getDecoratorName(decorator) === 'Provides') {
+        convertProviderParamsToDestructuringAssignment(node);
+        saveUnmangledMethodNameInProviderArguments(node, decorator!);
+      }
+    },
+  },
+};
+
+function convertProviderParamsToDestructuringAssignment(node: ClassMethod) {
+  node.params.fill(paramsToDestructuringAssignment(node.params));
+}
+
+function saveUnmangledMethodNameInProviderArguments(node: ClassMethod, decorator: Decorator) {
+  if (providerIsNotNamed(decorator)) {
+    addNameToProviderArguments(node, decorator);
+  }
+}
+
+export default function plugin() {
+  return providerArgumentsTransformer;
+}

package/tsconfig.base.json

@@ -0,0 +1,43 @@
+{
+  "include": [
+    "src/**/*",
+    "transformers/**/*",
+    "test/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ],
+  "compilerOptions": {
+    "target": "es5",
+    "module": "commonjs",
+    "lib": [
+      "ES6",
+      "DOM",
+      "esnext"
+    ],
+    "moduleResolution": "node",
+    "outDir": "./dist",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "strict": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitOverride": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "forceConsistentCasingInFileNames": true,
+    "jsx": "react",
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "types": ["reflect-metadata", "jest"],
+    "baseUrl": "./",
+    "paths": {
+      "@Obsidian": ["./src/@types/obsidian.d.ts"]
+    },
+  }
+}

package/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "./tsconfig.base.json"
+}

package/tsconfig.prod.json

@@ -0,0 +1,7 @@
+{
+  "extends": "./tsconfig.base.json",
+  "exclude": [
+    "**/*.test.*",
+    "test"
+  ]
+}