@layerzerolabs/dfs 0.0.1 → 0.0.5

package/.turbo/turbo-build.log

@@ -1,21 +1,18 @@
-
-
-> @layerzerolabs/dfs@0.0.1 build /Users/ivan.kurinnyi/project/monorepo-internal/packages/dfs
-> tsup
-
-CLI Building entry: src/index.ts
-CLI Using tsconfig: tsconfig.json
-CLI tsup v8.4.0
-CLI Using tsup config: /Users/ivan.kurinnyi/project/monorepo-internal/packages/dfs/tsup.config.ts
-CLI Target: es2022
-CLI Cleaning output folder
-CJS Build start
-ESM Build start
-ESM You have emitDecoratorMetadata enabled but @swc/core was not installed, skipping swc plugin
-ESM You have emitDecoratorMetadata enabled but @swc/core was not installed, skipping swc plugin
-CJS dist/index.cjs     950.00 B
-CJS dist/index.cjs.map 2.98 KB
-CJS ⚡️ Build success in 27ms
-ESM dist/index.js     928.00 B
-ESM dist/index.js.map 2.98 KB
-ESM ⚡️ Build success in 27ms
+
+> @layerzerolabs/dfs@0.0.2 build /home/runner/work/monorepo-internal/monorepo-internal/packages/dfs
+> tsup
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.4.0
+CLI Using tsup config: /home/runner/work/monorepo-internal/monorepo-internal/packages/dfs/tsup.config.ts
+CLI Target: es2022
+CLI Cleaning output folder
+CJS Build start
+ESM Build start
+CJS dist/index.cjs     1.40 KB
+CJS dist/index.cjs.map 5.35 KB
+CJS ⚡️ Build success in 88ms
+ESM dist/index.js     1.38 KB
+ESM dist/index.js.map 5.35 KB
+ESM ⚡️ Build success in 88ms

package/.turbo/turbo-lint.log

@@ -0,0 +1,4 @@
+
+> @layerzerolabs/dfs@0.0.2 lint /home/runner/work/monorepo-internal/monorepo-internal/packages/dfs
+> eslint . --max-warnings 0
+

package/.turbo/turbo-test.log

@@ -0,0 +1,15 @@
+
+> @layerzerolabs/dfs@0.0.2 test /home/runner/work/monorepo-internal/monorepo-internal/packages/dfs
+> vitest --run --pass-with-no-tests
+
+
+ RUN  v3.2.3 /home/runner/work/monorepo-internal/monorepo-internal/packages/dfs
+
+ ✓ test/dfs.test.ts (3 tests) 308ms
+   ✓ DI Depth-first-search > The handlers for each of a node's dependencies should be completed before that node  303ms
+
+ Test Files  1 passed (1)
+      Tests  3 passed (3)
+   Start at  16:40:53
+   Duration  987ms (transform 140ms, setup 0ms, collect 74ms, tests 308ms, environment 0ms, prepare 317ms)
+

package/dist/index.cjs

@@ -1,38 +1,48 @@
 'use strict';
 
-require('reflect-metadata');
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/index.ts
-var dfs = (node, handler, _visited = /* @__PURE__ */ new Map(), _returns = {}) => {
-  if (_visited.has(node.name)) {
+var dfs = /* @__PURE__ */ __name((node, handler, prehandler = (node2) => node2, _visited = /* @__PURE__ */ new Map(), _returns = {}, _backtrack = []) => {
+  const _node = prehandler(node);
+  if (_visited.has(_node.name)) {
     return async () => {
-      await _visited.get(node.name);
+      await _visited.get(_node.name);
       return _returns;
     };
   }
   let resolver;
-  _visited.set(
-    node.name,
-    new Promise((res) => {
-      resolver = res;
-    })
-  );
+  _visited.set(_node.name, new Promise((res) => {
+    resolver = res;
+  }));
   const resolverFunctions = [];
-  if (node.dependencies) {
-    for (const [_, dependencyValue] of Object.entries(node.dependencies)) {
-      resolverFunctions.push(dfs(dependencyValue, handler, _visited, _returns));
+  if (_node.dependencies) {
+    const nextBacktrack = [
+      ..._backtrack,
+      _node
+    ];
+    for (const [_, dependencyValue] of Object.entries(_node.dependencies)) {
+      resolverFunctions.push(dfs(dependencyValue, handler, prehandler, _visited, _returns, nextBacktrack));
     }
   }
   return async () => {
-    await Promise.all(resolverFunctions.map((f) => f()));
-    const regRes = await handler(node);
-    if (regRes) {
-      (_returns[regRes.key] ??= {})[node.name] = regRes.value;
+    try {
+      await Promise.all(resolverFunctions.map((f) => f()));
+      const regRes = await handler(_node);
+      if (regRes) {
+        (_returns[regRes.key] ??= {})[_node.name] = regRes.value;
+      }
+      resolver();
+      return _returns;
+    } catch (error) {
+      throw new Error(`Failed at ${_backtrack.map((n) => n.name).join("/")}.
+${error?.message}`, {
+        cause: error
+      });
     }
-    resolver();
-    return _returns;
   };
-};
+}, "dfs");
 
 exports.dfs = dfs;
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"names":[],"mappings":";;;;;AAgBa,IAAA,GAAA,GAAM,CACf,IAAA,EACA,OACA,EAAA,QAAA,uBAA2C,GAAI,EAAA,EAC/C,QAAwB,GAAA,EACO,KAAA;AAC/B,EAAA,IAAI,QAAS,CAAA,GAAA,CAAI,IAAK,CAAA,IAAI,CAAG,EAAA;AACzB,IAAA,OAAO,YAAY;AACf,MAAM,MAAA,QAAA,CAAS,GAAI,CAAA,IAAA,CAAK,IAAI,CAAA;AAC5B,MAAO,OAAA,QAAA;AAAA,KACX;AAAA;AAEJ,EAAI,IAAA,QAAA;AAEJ,EAAS,QAAA,CAAA,GAAA;AAAA,IACL,IAAK,CAAA,IAAA;AAAA,IACL,IAAI,OAAc,CAAA,CAAC,GAAQ,KAAA;AACvB,MAAW,QAAA,GAAA,GAAA;AAAA,KACd;AAAA,GACL;AAGA,EAAA,MAAM,oBAA4C,EAAC;AACnD,EAAA,IAAI,KAAK,YAAc,EAAA;AACnB,IAAW,KAAA,MAAA,CAAC,GAAG,eAAe,CAAA,IAAK,OAAO,OAAQ,CAAA,IAAA,CAAK,YAAY,CAAG,EAAA;AAClE,MAAA,iBAAA,CAAkB,KAAK,GAAI,CAAA,eAAA,EAAiB,OAAS,EAAA,QAAA,EAAU,QAAQ,CAAC,CAAA;AAAA;AAC5E;AAGJ,EAAA,OAAO,YAAY;AACf,IAAM,MAAA,OAAA,CAAQ,IAAI,iBAAkB,CAAA,GAAA,CAAI,CAAC,CAAM,KAAA,CAAA,EAAG,CAAC,CAAA;AACnD,IAAM,MAAA,MAAA,GAAS,MAAM,OAAA,CAAQ,IAAI,CAAA;AACjC,IAAA,IAAI,MAAQ,EAAA;AACR,MAAE,CAAA,QAAA,CAAiB,OAAO,GAAG,CAAA,KAAM,EAAI,EAAA,IAAA,CAAK,IAAI,CAAA,GAAI,MAAO,CAAA,KAAA;AAAA;AAE/D,IAAS,QAAA,EAAA;AACT,IAAO,OAAA,QAAA;AAAA,GACX;AACJ","file":"index.cjs","sourcesContent":["import type { Dependencies, DependencyNode } from '@layerzerolabs/dependency-graph';\n\nexport interface Registrar<ReturnType> {\n    traverseDependencies: (rootNode: DependencyNode<any, any>) => Promise<ReturnType>;\n}\nexport type NodeHandlerFunction = (\n    node: DependencyNode<any, Dependencies>,\n) => Promise<{ key: string; value: any }>;\n\n/**\n * Performs a depth-first-search on a tree of dependency nodes, using the provided registrar map\n * to register the nodes into the root tsyringe container.\n * @param node the root node of the tree\n * @param handler a function that accepts a node and registers it\n * @returns all pure dependencies of the node\n */\nexport const dfs = <DependencyName extends string, ReturnTypes>(\n    node: DependencyNode<DependencyName, Dependencies>,\n    handler: NodeHandlerFunction,\n    _visited: Map<string, Promise<void>> = new Map(),\n    _returns: ReturnTypes = {} as any,\n): (() => Promise<ReturnTypes>) => {\n    if (_visited.has(node.name)) {\n        return async () => {\n            await _visited.get(node.name);\n            return _returns;\n        };\n    }\n    let resolver: (value: void | PromiseLike<void>) => void;\n\n    _visited.set(\n        node.name,\n        new Promise<void>((res) => {\n            resolver = res;\n        }),\n    );\n\n    // Resolve dependencies first\n    const resolverFunctions: (() => Promise<any>)[] = [];\n    if (node.dependencies) {\n        for (const [_, dependencyValue] of Object.entries(node.dependencies)) {\n            resolverFunctions.push(dfs(dependencyValue, handler, _visited, _returns));\n        }\n    }\n\n    return async () => {\n        await Promise.all(resolverFunctions.map((f) => f()));\n        const regRes = await handler(node);\n        if (regRes) {\n            ((_returns as any)[regRes.key] ??= {})[node.name] = regRes.value;\n        }\n        resolver();\n        return _returns;\n    };\n};\n"]}
+{"version":3,"sources":["../src/index.ts"],"names":["dfs","node","handler","prehandler","_visited","Map","_returns","_backtrack","_node","has","name","get","resolver","set","Promise","res","resolverFunctions","dependencies","nextBacktrack","_","dependencyValue","Object","entries","push","all","map","f","regRes","key","value","error","Error","n","join","message","cause"],"mappings":";;;;;;AA8BO,IAAMA,sBAAM,MAAA,CAAA,CACfC,IAAAA,EACAC,OAAAA,EACAC,UAAAA,GAAqC,CAACF,KAAAA,KAASA,KAAAA,EAC/CG,QAAAA,mBAAuC,IAAIC,KAAAA,EAC3CC,QAAAA,GAAwB,EAAC,EACzBC,UAAAA,GAA6D,EAAA,KAAE;AAE/D,EAAA,MAAMC,KAAAA,GAAQL,WAAWF,IAAAA,CAAAA;AACzB,EAAA,IAAIG,QAAAA,CAASK,GAAAA,CAAID,KAAAA,CAAME,IAAI,CAAA,EAAG;AAC1B,IAAA,OAAO,YAAA;AACH,MAAA,MAAMN,QAAAA,CAASO,GAAAA,CAAIH,KAAAA,CAAME,IAAI,CAAA;AAC7B,MAAA,OAAOJ,QAAAA;AACX,IAAA,CAAA;AACJ,EAAA;AACA,EAAA,IAAIM,QAAAA;AAEJR,EAAAA,QAAAA,CAASS,IACLL,KAAAA,CAAME,IAAAA,EACN,IAAII,OAAAA,CAAc,CAACC,GAAAA,KAAAA;AACfH,IAAAA,QAAAA,GAAWG,GAAAA;AACf,EAAA,CAAA,CAAA,CAAA;AAIJ,EAAA,MAAMC,oBAA4C,EAAA;AAClD,EAAA,IAAIR,MAAMS,YAAAA,EAAc;AACpB,IAAA,MAAMC,aAAAA,GAAgB;AAAIX,MAAAA,GAAAA,UAAAA;AAAYC,MAAAA;;AACtC,IAAA,KAAA,MAAW,CAACW,GAAGC,eAAAA,CAAAA,IAAoBC,OAAOC,OAAAA,CAAQd,KAAAA,CAAMS,YAAY,CAAA,EAAG;AACnED,MAAAA,iBAAAA,CAAkBO,IAAAA,CACdvB,IAAIoB,eAAAA,EAAiBlB,OAAAA,EAASC,YAAYC,QAAAA,EAAUE,QAAAA,EAAUY,aAAAA,CAAAA,CAAAA;AAEtE,IAAA;AACJ,EAAA;AAEA,EAAA,OAAO,YAAA;AACH,IAAA,IAAI;AACA,MAAA,MAAMJ,OAAAA,CAAQU,IAAIR,iBAAAA,CAAkBS,GAAAA,CAAI,CAACC,CAAAA,KAAMA,CAAAA,EAAAA,CAAAA,CAAAA;AAC/C,MAAA,MAAMC,MAAAA,GAAS,MAAMzB,OAAAA,CAAQM,KAAAA,CAAAA;AAC7B,MAAA,IAAImB,MAAAA,EAAQ;AACP,QAAA,CAACrB,QAAAA,CAAiBqB,OAAOC,GAAG,CAAA,KAAM,EAAC,EAAGpB,KAAAA,CAAME,IAAI,CAAA,GAAIiB,MAAAA,CAAOE,KAAAA;AAChE,MAAA;AACAjB,MAAAA,QAAAA,EAAAA;AACA,MAAA,OAAON,QAAAA;AACX,IAAA,CAAA,CAAA,OAASwB,KAAAA,EAAY;AACjB,MAAA,MAAM,IAAIC,KAAAA,CACN,CAAA,UAAA,EAAaxB,UAAAA,CAAWkB,GAAAA,CAAI,CAACO,CAAAA,KAAMA,CAAAA,CAAEtB,IAAI,CAAA,CAAEuB,IAAAA,CAAK,GAAA,CAAA,CAAA;AAAUH,EAAAA,KAAAA,EAAOI,OAAAA,CAAAA,CAAAA,EACjE;QAAEC,KAAAA,EAAOL;OAAM,CAAA;AAEvB,IAAA;AACJ,EAAA,CAAA;AACJ,CAAA,EAnDmB,KAAA","file":"index.cjs","sourcesContent":["import type { Dependencies, DependencyNode } from '@layerzerolabs/dependency-graph';\n\n/**\n * A registrar is a simple interface for an object that provides the ability to traverse the dependency graph.\n * It is implicit in this definition that the registrar should also *register* values adhering to the schemata\n * of the graph.\n */\nexport interface Registrar<ReturnType> {\n    traverseDependencies: (rootNode: DependencyNode<any, any>) => Promise<ReturnType>;\n}\nexport type NodeHandlerFunction = (\n    node: DependencyNode<any, Dependencies>,\n) => Promise<{ key: string; value: any }>;\nexport type NodePreHandlerFunction = (\n    node: DependencyNode<any, Dependencies>,\n) => DependencyNode<any, Dependencies>;\n\n/**\n * Performs a depth-first-search on a tree of dependency nodes, and returns a function\n * that will call the handler for each node in the tree, ordered s.t. the handler of N\n * will be called only after the handlers of dependencies(N) have been called.\n * The resolver function will only call the handler once for each unique definition node.\n * The resolver function returns an object whose keys are the keys defined\n * by each of the handlers, and whose values are objects whose keys are the names\n * of the nodes resolved and whose values are the values defined by the handlers.\n * @param node the root node of the tree\n * @param handler a function that accepts a node and registers it\n * @param prehandler a function that accepts a node and returns a node. will be use to pre-process the graph\n * @returns a resolver function\n */\nexport const dfs = <DependencyName extends string, ReturnTypes>(\n    node: DependencyNode<DependencyName, Dependencies>,\n    handler: NodeHandlerFunction,\n    prehandler: NodePreHandlerFunction = (node) => node,\n    _visited: Map<string, Promise<void>> = new Map(),\n    _returns: ReturnTypes = {} as any,\n    _backtrack: DependencyNode<DependencyName, Dependencies>[] = [],\n): (() => Promise<ReturnTypes>) => {\n    const _node = prehandler(node);\n    if (_visited.has(_node.name)) {\n        return async () => {\n            await _visited.get(_node.name);\n            return _returns;\n        };\n    }\n    let resolver: (value: void | PromiseLike<void>) => void;\n\n    _visited.set(\n        _node.name,\n        new Promise<void>((res) => {\n            resolver = res;\n        }),\n    );\n\n    // Resolve dependencies first\n    const resolverFunctions: (() => Promise<any>)[] = [];\n    if (_node.dependencies) {\n        const nextBacktrack = [..._backtrack, _node];\n        for (const [_, dependencyValue] of Object.entries(_node.dependencies)) {\n            resolverFunctions.push(\n                dfs(dependencyValue, handler, prehandler, _visited, _returns, nextBacktrack),\n            );\n        }\n    }\n\n    return async () => {\n        try {\n            await Promise.all(resolverFunctions.map((f) => f()));\n            const regRes = await handler(_node);\n            if (regRes) {\n                ((_returns as any)[regRes.key] ??= {})[_node.name] = regRes.value;\n            }\n            resolver();\n            return _returns;\n        } catch (error: any) {\n            throw new Error(\n                `Failed at ${_backtrack.map((n) => n.name).join('/')}.\\n${error?.message}`,\n                { cause: error },\n            );\n        }\n    };\n};\n"]}

package/dist/index.d.ts

@@ -1,4 +1,9 @@
 import type { Dependencies, DependencyNode } from '@layerzerolabs/dependency-graph';
+/**
+ * A registrar is a simple interface for an object that provides the ability to traverse the dependency graph.
+ * It is implicit in this definition that the registrar should also *register* values adhering to the schemata
+ * of the graph.
+ */
 export interface Registrar<ReturnType> {
     traverseDependencies: (rootNode: DependencyNode<any, any>) => Promise<ReturnType>;
 }
@@ -6,12 +11,19 @@ export type NodeHandlerFunction = (node: DependencyNode<any, Dependencies>) => P
     key: string;
     value: any;
 }>;
+export type NodePreHandlerFunction = (node: DependencyNode<any, Dependencies>) => DependencyNode<any, Dependencies>;
 /**
- * Performs a depth-first-search on a tree of dependency nodes, using the provided registrar map
- * to register the nodes into the root tsyringe container.
+ * Performs a depth-first-search on a tree of dependency nodes, and returns a function
+ * that will call the handler for each node in the tree, ordered s.t. the handler of N
+ * will be called only after the handlers of dependencies(N) have been called.
+ * The resolver function will only call the handler once for each unique definition node.
+ * The resolver function returns an object whose keys are the keys defined
+ * by each of the handlers, and whose values are objects whose keys are the names
+ * of the nodes resolved and whose values are the values defined by the handlers.
  * @param node the root node of the tree
  * @param handler a function that accepts a node and registers it
- * @returns all pure dependencies of the node
+ * @param prehandler a function that accepts a node and returns a node. will be use to pre-process the graph
+ * @returns a resolver function
  */
-export declare const dfs: <DependencyName extends string, ReturnTypes>(node: DependencyNode<DependencyName, Dependencies>, handler: NodeHandlerFunction, _visited?: Map<string, Promise<void>>, _returns?: ReturnTypes) => (() => Promise<ReturnTypes>);
+export declare const dfs: <DependencyName extends string, ReturnTypes>(node: DependencyNode<DependencyName, Dependencies>, handler: NodeHandlerFunction, prehandler?: NodePreHandlerFunction, _visited?: Map<string, Promise<void>>, _returns?: ReturnTypes, _backtrack?: DependencyNode<DependencyName, Dependencies>[]) => (() => Promise<ReturnTypes>);
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAEpF,MAAM,WAAW,SAAS,CAAC,UAAU;IACjC,oBAAoB,EAAE,CAAC,QAAQ,EAAE,cAAc,CAAC,GAAG,EAAE,GAAG,CAAC,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;CACrF;AACD,MAAM,MAAM,mBAAmB,GAAG,CAC9B,IAAI,EAAE,cAAc,CAAC,GAAG,EAAE,YAAY,CAAC,KACtC,OAAO,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,GAAG,CAAA;CAAE,CAAC,CAAC;AAE1C;;;;;;GAMG;AACH,eAAO,MAAM,GAAG,GAAI,cAAc,SAAS,MAAM,EAAE,WAAW,EAC1D,MAAM,cAAc,CAAC,cAAc,EAAE,YAAY,CAAC,EAClD,SAAS,mBAAmB,EAC5B,WAAU,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,CAAa,EAChD,WAAU,WAAuB,KAClC,CAAC,MAAM,OAAO,CAAC,WAAW,CAAC,CAiC7B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAEpF;;;;GAIG;AACH,MAAM,WAAW,SAAS,CAAC,UAAU;IACjC,oBAAoB,EAAE,CAAC,QAAQ,EAAE,cAAc,CAAC,GAAG,EAAE,GAAG,CAAC,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;CACrF;AACD,MAAM,MAAM,mBAAmB,GAAG,CAC9B,IAAI,EAAE,cAAc,CAAC,GAAG,EAAE,YAAY,CAAC,KACtC,OAAO,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,GAAG,CAAA;CAAE,CAAC,CAAC;AAC1C,MAAM,MAAM,sBAAsB,GAAG,CACjC,IAAI,EAAE,cAAc,CAAC,GAAG,EAAE,YAAY,CAAC,KACtC,cAAc,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC;AAEvC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,GAAG,GAAI,cAAc,SAAS,MAAM,EAAE,WAAW,EAC1D,MAAM,cAAc,CAAC,cAAc,EAAE,YAAY,CAAC,EAClD,SAAS,mBAAmB,EAC5B,aAAY,sBAAuC,EACnD,WAAU,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,CAAa,EAChD,WAAU,WAAuB,EACjC,aAAY,cAAc,CAAC,cAAc,EAAE,YAAY,CAAC,EAAO,KAChE,CAAC,MAAM,OAAO,CAAC,WAAW,CAAC,CA4C7B,CAAC"}

package/dist/index.js

@@ -1,36 +1,46 @@
-import 'reflect-metadata';
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/index.ts
-var dfs = (node, handler, _visited = /* @__PURE__ */ new Map(), _returns = {}) => {
-  if (_visited.has(node.name)) {
+var dfs = /* @__PURE__ */ __name((node, handler, prehandler = (node2) => node2, _visited = /* @__PURE__ */ new Map(), _returns = {}, _backtrack = []) => {
+  const _node = prehandler(node);
+  if (_visited.has(_node.name)) {
     return async () => {
-      await _visited.get(node.name);
+      await _visited.get(_node.name);
       return _returns;
     };
   }
   let resolver;
-  _visited.set(
-    node.name,
-    new Promise((res) => {
-      resolver = res;
-    })
-  );
+  _visited.set(_node.name, new Promise((res) => {
+    resolver = res;
+  }));
   const resolverFunctions = [];
-  if (node.dependencies) {
-    for (const [_, dependencyValue] of Object.entries(node.dependencies)) {
-      resolverFunctions.push(dfs(dependencyValue, handler, _visited, _returns));
+  if (_node.dependencies) {
+    const nextBacktrack = [
+      ..._backtrack,
+      _node
+    ];
+    for (const [_, dependencyValue] of Object.entries(_node.dependencies)) {
+      resolverFunctions.push(dfs(dependencyValue, handler, prehandler, _visited, _returns, nextBacktrack));
     }
   }
   return async () => {
-    await Promise.all(resolverFunctions.map((f) => f()));
-    const regRes = await handler(node);
-    if (regRes) {
-      (_returns[regRes.key] ??= {})[node.name] = regRes.value;
+    try {
+      await Promise.all(resolverFunctions.map((f) => f()));
+      const regRes = await handler(_node);
+      if (regRes) {
+        (_returns[regRes.key] ??= {})[_node.name] = regRes.value;
+      }
+      resolver();
+      return _returns;
+    } catch (error) {
+      throw new Error(`Failed at ${_backtrack.map((n) => n.name).join("/")}.
+${error?.message}`, {
+        cause: error
+      });
     }
-    resolver();
-    return _returns;
   };
-};
+}, "dfs");
 
 export { dfs };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"names":[],"mappings":";;;AAgBa,IAAA,GAAA,GAAM,CACf,IAAA,EACA,OACA,EAAA,QAAA,uBAA2C,GAAI,EAAA,EAC/C,QAAwB,GAAA,EACO,KAAA;AAC/B,EAAA,IAAI,QAAS,CAAA,GAAA,CAAI,IAAK,CAAA,IAAI,CAAG,EAAA;AACzB,IAAA,OAAO,YAAY;AACf,MAAM,MAAA,QAAA,CAAS,GAAI,CAAA,IAAA,CAAK,IAAI,CAAA;AAC5B,MAAO,OAAA,QAAA;AAAA,KACX;AAAA;AAEJ,EAAI,IAAA,QAAA;AAEJ,EAAS,QAAA,CAAA,GAAA;AAAA,IACL,IAAK,CAAA,IAAA;AAAA,IACL,IAAI,OAAc,CAAA,CAAC,GAAQ,KAAA;AACvB,MAAW,QAAA,GAAA,GAAA;AAAA,KACd;AAAA,GACL;AAGA,EAAA,MAAM,oBAA4C,EAAC;AACnD,EAAA,IAAI,KAAK,YAAc,EAAA;AACnB,IAAW,KAAA,MAAA,CAAC,GAAG,eAAe,CAAA,IAAK,OAAO,OAAQ,CAAA,IAAA,CAAK,YAAY,CAAG,EAAA;AAClE,MAAA,iBAAA,CAAkB,KAAK,GAAI,CAAA,eAAA,EAAiB,OAAS,EAAA,QAAA,EAAU,QAAQ,CAAC,CAAA;AAAA;AAC5E;AAGJ,EAAA,OAAO,YAAY;AACf,IAAM,MAAA,OAAA,CAAQ,IAAI,iBAAkB,CAAA,GAAA,CAAI,CAAC,CAAM,KAAA,CAAA,EAAG,CAAC,CAAA;AACnD,IAAM,MAAA,MAAA,GAAS,MAAM,OAAA,CAAQ,IAAI,CAAA;AACjC,IAAA,IAAI,MAAQ,EAAA;AACR,MAAE,CAAA,QAAA,CAAiB,OAAO,GAAG,CAAA,KAAM,EAAI,EAAA,IAAA,CAAK,IAAI,CAAA,GAAI,MAAO,CAAA,KAAA;AAAA;AAE/D,IAAS,QAAA,EAAA;AACT,IAAO,OAAA,QAAA;AAAA,GACX;AACJ","file":"index.js","sourcesContent":["import type { Dependencies, DependencyNode } from '@layerzerolabs/dependency-graph';\n\nexport interface Registrar<ReturnType> {\n    traverseDependencies: (rootNode: DependencyNode<any, any>) => Promise<ReturnType>;\n}\nexport type NodeHandlerFunction = (\n    node: DependencyNode<any, Dependencies>,\n) => Promise<{ key: string; value: any }>;\n\n/**\n * Performs a depth-first-search on a tree of dependency nodes, using the provided registrar map\n * to register the nodes into the root tsyringe container.\n * @param node the root node of the tree\n * @param handler a function that accepts a node and registers it\n * @returns all pure dependencies of the node\n */\nexport const dfs = <DependencyName extends string, ReturnTypes>(\n    node: DependencyNode<DependencyName, Dependencies>,\n    handler: NodeHandlerFunction,\n    _visited: Map<string, Promise<void>> = new Map(),\n    _returns: ReturnTypes = {} as any,\n): (() => Promise<ReturnTypes>) => {\n    if (_visited.has(node.name)) {\n        return async () => {\n            await _visited.get(node.name);\n            return _returns;\n        };\n    }\n    let resolver: (value: void | PromiseLike<void>) => void;\n\n    _visited.set(\n        node.name,\n        new Promise<void>((res) => {\n            resolver = res;\n        }),\n    );\n\n    // Resolve dependencies first\n    const resolverFunctions: (() => Promise<any>)[] = [];\n    if (node.dependencies) {\n        for (const [_, dependencyValue] of Object.entries(node.dependencies)) {\n            resolverFunctions.push(dfs(dependencyValue, handler, _visited, _returns));\n        }\n    }\n\n    return async () => {\n        await Promise.all(resolverFunctions.map((f) => f()));\n        const regRes = await handler(node);\n        if (regRes) {\n            ((_returns as any)[regRes.key] ??= {})[node.name] = regRes.value;\n        }\n        resolver();\n        return _returns;\n    };\n};\n"]}
+{"version":3,"sources":["../src/index.ts"],"names":["dfs","node","handler","prehandler","_visited","Map","_returns","_backtrack","_node","has","name","get","resolver","set","Promise","res","resolverFunctions","dependencies","nextBacktrack","_","dependencyValue","Object","entries","push","all","map","f","regRes","key","value","error","Error","n","join","message","cause"],"mappings":";;;;AA8BO,IAAMA,sBAAM,MAAA,CAAA,CACfC,IAAAA,EACAC,OAAAA,EACAC,UAAAA,GAAqC,CAACF,KAAAA,KAASA,KAAAA,EAC/CG,QAAAA,mBAAuC,IAAIC,KAAAA,EAC3CC,QAAAA,GAAwB,EAAC,EACzBC,UAAAA,GAA6D,EAAA,KAAE;AAE/D,EAAA,MAAMC,KAAAA,GAAQL,WAAWF,IAAAA,CAAAA;AACzB,EAAA,IAAIG,QAAAA,CAASK,GAAAA,CAAID,KAAAA,CAAME,IAAI,CAAA,EAAG;AAC1B,IAAA,OAAO,YAAA;AACH,MAAA,MAAMN,QAAAA,CAASO,GAAAA,CAAIH,KAAAA,CAAME,IAAI,CAAA;AAC7B,MAAA,OAAOJ,QAAAA;AACX,IAAA,CAAA;AACJ,EAAA;AACA,EAAA,IAAIM,QAAAA;AAEJR,EAAAA,QAAAA,CAASS,IACLL,KAAAA,CAAME,IAAAA,EACN,IAAII,OAAAA,CAAc,CAACC,GAAAA,KAAAA;AACfH,IAAAA,QAAAA,GAAWG,GAAAA;AACf,EAAA,CAAA,CAAA,CAAA;AAIJ,EAAA,MAAMC,oBAA4C,EAAA;AAClD,EAAA,IAAIR,MAAMS,YAAAA,EAAc;AACpB,IAAA,MAAMC,aAAAA,GAAgB;AAAIX,MAAAA,GAAAA,UAAAA;AAAYC,MAAAA;;AACtC,IAAA,KAAA,MAAW,CAACW,GAAGC,eAAAA,CAAAA,IAAoBC,OAAOC,OAAAA,CAAQd,KAAAA,CAAMS,YAAY,CAAA,EAAG;AACnED,MAAAA,iBAAAA,CAAkBO,IAAAA,CACdvB,IAAIoB,eAAAA,EAAiBlB,OAAAA,EAASC,YAAYC,QAAAA,EAAUE,QAAAA,EAAUY,aAAAA,CAAAA,CAAAA;AAEtE,IAAA;AACJ,EAAA;AAEA,EAAA,OAAO,YAAA;AACH,IAAA,IAAI;AACA,MAAA,MAAMJ,OAAAA,CAAQU,IAAIR,iBAAAA,CAAkBS,GAAAA,CAAI,CAACC,CAAAA,KAAMA,CAAAA,EAAAA,CAAAA,CAAAA;AAC/C,MAAA,MAAMC,MAAAA,GAAS,MAAMzB,OAAAA,CAAQM,KAAAA,CAAAA;AAC7B,MAAA,IAAImB,MAAAA,EAAQ;AACP,QAAA,CAACrB,QAAAA,CAAiBqB,OAAOC,GAAG,CAAA,KAAM,EAAC,EAAGpB,KAAAA,CAAME,IAAI,CAAA,GAAIiB,MAAAA,CAAOE,KAAAA;AAChE,MAAA;AACAjB,MAAAA,QAAAA,EAAAA;AACA,MAAA,OAAON,QAAAA;AACX,IAAA,CAAA,CAAA,OAASwB,KAAAA,EAAY;AACjB,MAAA,MAAM,IAAIC,KAAAA,CACN,CAAA,UAAA,EAAaxB,UAAAA,CAAWkB,GAAAA,CAAI,CAACO,CAAAA,KAAMA,CAAAA,CAAEtB,IAAI,CAAA,CAAEuB,IAAAA,CAAK,GAAA,CAAA,CAAA;AAAUH,EAAAA,KAAAA,EAAOI,OAAAA,CAAAA,CAAAA,EACjE;QAAEC,KAAAA,EAAOL;OAAM,CAAA;AAEvB,IAAA;AACJ,EAAA,CAAA;AACJ,CAAA,EAnDmB,KAAA","file":"index.js","sourcesContent":["import type { Dependencies, DependencyNode } from '@layerzerolabs/dependency-graph';\n\n/**\n * A registrar is a simple interface for an object that provides the ability to traverse the dependency graph.\n * It is implicit in this definition that the registrar should also *register* values adhering to the schemata\n * of the graph.\n */\nexport interface Registrar<ReturnType> {\n    traverseDependencies: (rootNode: DependencyNode<any, any>) => Promise<ReturnType>;\n}\nexport type NodeHandlerFunction = (\n    node: DependencyNode<any, Dependencies>,\n) => Promise<{ key: string; value: any }>;\nexport type NodePreHandlerFunction = (\n    node: DependencyNode<any, Dependencies>,\n) => DependencyNode<any, Dependencies>;\n\n/**\n * Performs a depth-first-search on a tree of dependency nodes, and returns a function\n * that will call the handler for each node in the tree, ordered s.t. the handler of N\n * will be called only after the handlers of dependencies(N) have been called.\n * The resolver function will only call the handler once for each unique definition node.\n * The resolver function returns an object whose keys are the keys defined\n * by each of the handlers, and whose values are objects whose keys are the names\n * of the nodes resolved and whose values are the values defined by the handlers.\n * @param node the root node of the tree\n * @param handler a function that accepts a node and registers it\n * @param prehandler a function that accepts a node and returns a node. will be use to pre-process the graph\n * @returns a resolver function\n */\nexport const dfs = <DependencyName extends string, ReturnTypes>(\n    node: DependencyNode<DependencyName, Dependencies>,\n    handler: NodeHandlerFunction,\n    prehandler: NodePreHandlerFunction = (node) => node,\n    _visited: Map<string, Promise<void>> = new Map(),\n    _returns: ReturnTypes = {} as any,\n    _backtrack: DependencyNode<DependencyName, Dependencies>[] = [],\n): (() => Promise<ReturnTypes>) => {\n    const _node = prehandler(node);\n    if (_visited.has(_node.name)) {\n        return async () => {\n            await _visited.get(_node.name);\n            return _returns;\n        };\n    }\n    let resolver: (value: void | PromiseLike<void>) => void;\n\n    _visited.set(\n        _node.name,\n        new Promise<void>((res) => {\n            resolver = res;\n        }),\n    );\n\n    // Resolve dependencies first\n    const resolverFunctions: (() => Promise<any>)[] = [];\n    if (_node.dependencies) {\n        const nextBacktrack = [..._backtrack, _node];\n        for (const [_, dependencyValue] of Object.entries(_node.dependencies)) {\n            resolverFunctions.push(\n                dfs(dependencyValue, handler, prehandler, _visited, _returns, nextBacktrack),\n            );\n        }\n    }\n\n    return async () => {\n        try {\n            await Promise.all(resolverFunctions.map((f) => f()));\n            const regRes = await handler(_node);\n            if (regRes) {\n                ((_returns as any)[regRes.key] ??= {})[_node.name] = regRes.value;\n            }\n            resolver();\n            return _returns;\n        } catch (error: any) {\n            throw new Error(\n                `Failed at ${_backtrack.map((n) => n.name).join('/')}.\\n${error?.message}`,\n                { cause: error },\n            );\n        }\n    };\n};\n"]}

package/package.json

@@ -1,22 +1,21 @@
 {
   "name": "@layerzerolabs/dfs",
-  "version": "0.0.1",
+  "version": "0.0.5",
   "license": "MIT",
   "main": "./dist/index.cjs",
   "types": "./dist/index.d.ts",
   "dependencies": {
-    "reflect-metadata": "^0.2.2",
-    "tsup": "^8.4.0",
-    "@layerzerolabs/dependency-graph": "0.0.1"
+    "@layerzerolabs/dependency-graph": "0.0.5"
   },
   "publishConfig": {
     "access": "restricted",
     "registry": "https://registry.npmjs.org/"
   },
   "devDependencies": {
-    "@layerzerolabs/eslint-configuration": "0.0.0",
-    "@layerzerolabs/typescript-configuration": "0.0.0",
-    "@layerzerolabs/tsup-configuration": "0.0.1"
+    "tsup": "^8.4.0",
+    "vitest": "^3.2.3",
+    "@layerzerolabs/typescript-configuration": "0.0.5",
+    "@layerzerolabs/tsup-configuration": "0.0.5"
   },
   "module": "./dist/index.js",
   "exports": {
@@ -32,7 +31,7 @@
     "build": "tsup",
     "lint": "eslint . --max-warnings 0",
     "lint:fix": "eslint . --fix --max-warnings 0",
-    "typecheck": "tsc --noEmit",
+    "test": "vitest --run --pass-with-no-tests",
     "dev": "tsup --watch"
   }
 }

package/src/index.ts

@@ -1,35 +1,52 @@
 import type { Dependencies, DependencyNode } from '@layerzerolabs/dependency-graph';
 
+/**
+ * A registrar is a simple interface for an object that provides the ability to traverse the dependency graph.
+ * It is implicit in this definition that the registrar should also *register* values adhering to the schemata
+ * of the graph.
+ */
 export interface Registrar<ReturnType> {
     traverseDependencies: (rootNode: DependencyNode<any, any>) => Promise<ReturnType>;
 }
 export type NodeHandlerFunction = (
     node: DependencyNode<any, Dependencies>,
 ) => Promise<{ key: string; value: any }>;
+export type NodePreHandlerFunction = (
+    node: DependencyNode<any, Dependencies>,
+) => DependencyNode<any, Dependencies>;
 
 /**
- * Performs a depth-first-search on a tree of dependency nodes, using the provided registrar map
- * to register the nodes into the root tsyringe container.
+ * Performs a depth-first-search on a tree of dependency nodes, and returns a function
+ * that will call the handler for each node in the tree, ordered s.t. the handler of N
+ * will be called only after the handlers of dependencies(N) have been called.
+ * The resolver function will only call the handler once for each unique definition node.
+ * The resolver function returns an object whose keys are the keys defined
+ * by each of the handlers, and whose values are objects whose keys are the names
+ * of the nodes resolved and whose values are the values defined by the handlers.
  * @param node the root node of the tree
  * @param handler a function that accepts a node and registers it
- * @returns all pure dependencies of the node
+ * @param prehandler a function that accepts a node and returns a node. will be use to pre-process the graph
+ * @returns a resolver function
  */
 export const dfs = <DependencyName extends string, ReturnTypes>(
     node: DependencyNode<DependencyName, Dependencies>,
     handler: NodeHandlerFunction,
+    prehandler: NodePreHandlerFunction = (node) => node,
     _visited: Map<string, Promise<void>> = new Map(),
     _returns: ReturnTypes = {} as any,
+    _backtrack: DependencyNode<DependencyName, Dependencies>[] = [],
 ): (() => Promise<ReturnTypes>) => {
-    if (_visited.has(node.name)) {
+    const _node = prehandler(node);
+    if (_visited.has(_node.name)) {
         return async () => {
-            await _visited.get(node.name);
+            await _visited.get(_node.name);
             return _returns;
         };
     }
     let resolver: (value: void | PromiseLike<void>) => void;
 
     _visited.set(
-        node.name,
+        _node.name,
         new Promise<void>((res) => {
             resolver = res;
         }),
@@ -37,19 +54,29 @@ export const dfs = <DependencyName extends string, ReturnTypes>(
 
     // Resolve dependencies first
     const resolverFunctions: (() => Promise<any>)[] = [];
-    if (node.dependencies) {
-        for (const [_, dependencyValue] of Object.entries(node.dependencies)) {
-            resolverFunctions.push(dfs(dependencyValue, handler, _visited, _returns));
+    if (_node.dependencies) {
+        const nextBacktrack = [..._backtrack, _node];
+        for (const [_, dependencyValue] of Object.entries(_node.dependencies)) {
+            resolverFunctions.push(
+                dfs(dependencyValue, handler, prehandler, _visited, _returns, nextBacktrack),
+            );
         }
     }
 
     return async () => {
-        await Promise.all(resolverFunctions.map((f) => f()));
-        const regRes = await handler(node);
-        if (regRes) {
-            ((_returns as any)[regRes.key] ??= {})[node.name] = regRes.value;
+        try {
+            await Promise.all(resolverFunctions.map((f) => f()));
+            const regRes = await handler(_node);
+            if (regRes) {
+                ((_returns as any)[regRes.key] ??= {})[_node.name] = regRes.value;
+            }
+            resolver();
+            return _returns;
+        } catch (error: any) {
+            throw new Error(
+                `Failed at ${_backtrack.map((n) => n.name).join('/')}.\n${error?.message}`,
+                { cause: error },
+            );
         }
-        resolver();
-        return _returns;
     };
 };

package/test/dfs.test.ts

@@ -0,0 +1,112 @@
+import { describe, expect, test } from 'vitest';
+
+import { Dependencies, DependencyNode } from '@layerzerolabs/dependency-graph';
+
+import { dfs } from '../src/';
+
+const SimpleClassA = class<
+    Name extends string,
+    _Dependencies extends Dependencies,
+> extends DependencyNode<Name, _Dependencies> {};
+
+const mySimpleClassA = new SimpleClassA({ name: 'MySimpleClassA' });
+
+const SimpleClassB = class<
+    Name extends string,
+    _Dependencies extends Dependencies,
+> extends DependencyNode<Name, _Dependencies> {};
+
+const mySimpleClassB = new SimpleClassB({
+    name: 'MySimpleClassB',
+    dependencies: { mySimpleClassA },
+});
+
+const SimpleClassC = class<
+    Name extends string,
+    _Dependencies extends Dependencies,
+> extends DependencyNode<Name, _Dependencies> {};
+
+const mySimpleClassC = new SimpleClassC({
+    name: 'MySimpleClassC',
+    dependencies: { mySimpleClassB },
+});
+
+const SimpleClassD = class<
+    Name extends string,
+    _Dependencies extends Dependencies,
+> extends DependencyNode<Name, _Dependencies> {};
+
+const mySimpleClassD = new SimpleClassD({
+    name: 'MySimpleClassD',
+    dependencies: { mySimpleClassC, mySimpleClassB, mySimpleClassA },
+});
+
+describe('DI Depth-first-search', () => {
+    test('Initial DFS and resolution should happen separately and return the expected structure', async () => {
+        let wasCalled = false;
+        const resolve = dfs(mySimpleClassA, async () => {
+            wasCalled = true;
+            return { key: 'nodeKey', value: 'nodeValue' };
+        });
+
+        //when called, dfs should traverse the tree and collect all the nodes,
+        //returning a function that will call the handler on each node
+        expect(resolve).toBeTypeOf('function');
+
+        //it shouldn't call the handler until the resolve function is called
+        expect(wasCalled).toBe(false);
+        const res = await resolve();
+        //the resolve method should await all of the handlers
+        expect(wasCalled).toBe(true);
+        //the resolve method should return an object whose keys are the keys defined
+        //by each of the handlers, and whose values are objects whose keys are the names
+        //of the nodes resolved and whose values are the values defined by the handlers
+        expect(res).toStrictEqual({ nodeKey: { MySimpleClassA: 'nodeValue' } });
+    });
+
+    test(`The handlers for each of a node's dependencies should be completed before that node`, async () => {
+        let order: string[] = [];
+
+        const handler: Parameters<typeof dfs>[1] = async (node) => {
+            const handlerRet = { key: '_', value: '_' };
+            if (node.name === mySimpleClassA.name) {
+                order.push('A');
+                await new Promise((res) => setTimeout(res, 50));
+                return handlerRet;
+            } else if (node.name === mySimpleClassB.name) {
+                order.push('B');
+                await new Promise((res) => setTimeout(res, 100));
+                return handlerRet;
+            } else if (node.name === mySimpleClassC.name) {
+                order.push('C');
+                return handlerRet;
+            }
+            throw new Error(`Unexpected node ${JSON.stringify(node)}`);
+        };
+
+        await dfs(mySimpleClassB, handler)();
+        expect(order).toStrictEqual(['A', 'B']);
+
+        order = [];
+
+        await dfs(mySimpleClassC, handler)();
+        expect(order).toStrictEqual(['A', 'B', 'C']);
+    });
+
+    test('The handler should be called only once for each unique node', async () => {
+        let count = 0;
+
+        const handler: Parameters<typeof dfs>[1] = async (_node) => {
+            count++;
+            return { key: '_', value: '_' };
+        };
+
+        await dfs(mySimpleClassB, handler)();
+        expect(count).toBe(2);
+
+        count = 0;
+
+        await dfs(mySimpleClassD, handler)();
+        expect(count).toBe(4);
+    });
+});

package/tsconfig.json

@@ -1,22 +1,11 @@
 {
-    "$schema": "https://json.schemastore.org/tsconfig",
-    "display": "Node 16",
+    "extends": "@layerzerolabs/typescript-configuration/tsconfig.base.json",
     "compilerOptions": {
-        "lib": ["es2020"],
-        "module": "commonjs",
-        "target": "es2020",
-        "experimentalDecorators": true,
-        "allowJs": true,
-        "strict": true,
-        "esModuleInterop": true,
-        "skipLibCheck": true,
-        "forceConsistentCasingInFileNames": true,
-        "sourceMap": true,
-        "strictPropertyInitialization": false,
-        "emitDecoratorMetadata": true,
-        "resolveJsonModule": true,
-        "outDir": "./dist",
         "rootDir": "./src",
+        "outDir": "./dist",
+        "strictPropertyInitialization": false,
+        "noUnusedLocals": false,
+        "noUnusedParameters": false,
         "jsx": "react-jsx"
     },
     "exclude": [

package/tsup.config.ts

@@ -4,7 +4,5 @@ import { createPackageTsupConfig } from '@layerzerolabs/tsup-configuration';
 
 export default defineConfig(({ watch }) => ({
     ...createPackageTsupConfig(),
-    entry: ['src/**/*.ts', 'src/**/*.tsx'],
-    splitting: true,
     clean: !watch,
 }));

package/.eslintrc.cjs

@@ -1,5 +0,0 @@
-/** @type {import("eslint").Linter.Config} */
-module.exports = {
-    root: true,
-    extends: [require.resolve('@layerzerolabs/eslint-configuration/base')],
-};

package/tsconfig.tsbuildinfo

@@ -1 +0,0 @@
-{"root":["./src/index.ts"],"version":"5.8.2"}