feat(core): adds replace; modifies traverse api

packages/core/src/create/application/index.ts

@@ -46,19 +46,20 @@ export function application(
     options
   );
 
-  // clone collection and add global errors
-  collection = clone(collection);
+  // add global errors
   const errors: {
     [P in GenericError]: ErrorType;
   } = {
     ServerError: error({ code: 'ServerError' }),
     ClientError: error({ code: 'ClientError' })
   };
-  for (const [name, error] of Object.entries(errors)) {
-    if (!collection.types[name]) {
-      collection.types[name] = error;
+  collection = {
+    ...collection,
+    types: {
+      ...errors,
+      ...collection.types
     }
-  }
+  };
 
   const internal: GenericError = 'ServerError';
   collection = intercepts(
@@ -100,9 +101,10 @@ export function application(
     )
   };
 
+  collection = clone(collection);
   traverse(
     collection,
-    (element, path) => {
+    (element, { path }) => {
       const name = opts.transform(path.slice(-1)[0], true);
 
       if (isElementType(element)) {

packages/core/src/create/intercepts.ts

@@ -6,9 +6,9 @@ import {
 } from '~/types';
 import { from, Observable } from 'rxjs';
 import { switchMap, mergeMap } from 'rxjs/operators';
-import clone from 'lodash.clonedeep';
 import { emptyIntercept, mergeServiceErrors } from '~/utils';
-import { traverse, isElementService, isServiceImplementation } from '~/inspect';
+import { isElementService, isServiceImplementation } from '~/inspect';
+import { replace } from '~/transform';
 
 export interface InterceptsCreateOptions {
   prepend?: boolean;
@@ -22,24 +22,22 @@ export function intercepts<T extends CollectionTree>(
   intercepts: InterceptImplementation[],
   options?: InterceptsCreateOptions
 ): T {
-  collection = clone(collection);
   const opts = Object.assign({ prepend: true }, options);
 
-  traverse(
+  return replace(
     { ...collection, types: {} },
     (element) => {
-      if (!isElementService(element) || !isServiceImplementation(element)) {
-        return;
-      }
-
-      element.intercepts = opts.prepend
-        ? intercepts.concat(element.intercepts || [])
-        : (element.intercepts || []).concat(intercepts);
+      return !isElementService(element) || !isServiceImplementation(element)
+        ? element
+        : {
+            ...element,
+            intercepts: opts.prepend
+              ? intercepts.concat(element.intercepts || [])
+              : (element.intercepts || []).concat(intercepts)
+          };
     },
     { deep: true, children: true, inline: true }
-  );
-
-  return collection;
+  ) as T;
 }
 
 /**

packages/core/src/index.ts

@@ -1,5 +1,6 @@
 export * from './create';
 export * from './generate';
 export * from './inspect';
+export * from './transform';
 export * from './types';
 export * from './errors';

packages/core/src/inspect/traverse.ts

@@ -0,0 +1,56 @@
+import {
+  QueryService,
+  MutationService,
+  SubscriptionService,
+  Element,
+  CollectionTree
+} from '~/types';
+import { replace } from '~/transform';
+
+export type TraverseInspectFn<
+  Q extends QueryService = QueryService,
+  M extends MutationService = MutationService,
+  S extends SubscriptionService = SubscriptionService
+> = (element: Element<Q, M, S>, data: TraverseInspectData) => void;
+
+export interface TraverseInspectData {
+  path: string[];
+  route: string[];
+}
+
+export interface TraverseInspectOptions {
+  /**
+   * Whether to traverse a collection's inner scopes. Default: `true`.
+   */
+  deep?: boolean;
+  /**
+   * Whether to traverse type's children services. Default: `false`.
+   */
+  children?: boolean;
+  /**
+   * Whether to traverse types within services. Default: `false`.
+   */
+  inline?: boolean;
+}
+
+/**
+ * Performs a collection traversal, with `cb` being called (top-down) for each `Element`.
+ */
+export function traverse<
+  Q extends QueryService = QueryService,
+  M extends MutationService = MutationService,
+  S extends SubscriptionService = SubscriptionService
+>(
+  collection: CollectionTree<Q, M, S>,
+  cb: TraverseInspectFn<Q, M, S>,
+  options?: TraverseInspectOptions
+): void {
+  replace(
+    collection,
+    (element, data) => {
+      cb(element, data);
+      return element;
+    },
+    options
+  );
+}

packages/core/src/transform/index.ts

@@ -0,0 +1 @@
+export * from './replace';