@thisisagile/easy 12.7.21 → 12.7.27

package/src/services/Api.ts

@@ -1,81 +1,70 @@
-import {FetchOptions, Uri} from '../types';
-import {HttpVerb, RequestOptions, RequestProvider, Response, toPageOptions} from '../http';
-import {AxiosProvider} from './AxiosProvider';
+import { FetchOptions, Store, Uri } from '../types';
+import { HttpVerb, Request, RequestOptions, RequestProvider, Response, toPageOptions } from '../http';
+import { AxiosProvider } from './AxiosProvider';
 
 export type RouteOptions = RequestOptions | FetchOptions;
 
 export class Api {
-    constructor(readonly provider: RequestProvider = new AxiosProvider()) {
-    }
+  constructor(readonly provider: RequestProvider = new AxiosProvider(), protected store?: Store<Response, Request>) {}
 
-    get(uri: Uri, options?: RouteOptions, transform?: (r: any) => any, transformError = (r: any) => r): Promise<Response> {
-        return this.provider.execute({
-            uri: uri.skip(toPageOptions(options)?.skip).take(toPageOptions(options)?.take),
-            verb: HttpVerb.Get,
-            transform,
-            transformError,
-            options: this.options(HttpVerb.Get, options),
-        });
-    }
+  get(uri: Uri, options?: RouteOptions, transform?: (r: any) => any, transformError = (r: any) => r): Promise<Response> {
+    return this.execute({
+      uri: uri.skip(toPageOptions(options)?.skip).take(toPageOptions(options)?.take),
+      verb: HttpVerb.Get,
+      transform,
+      transformError,
+      options: this.options(HttpVerb.Get, options),
+    });
+  }
 
-    post(
-        uri: Uri,
-        body?: unknown,
-        options: RouteOptions = RequestOptions.Json,
-        transform?: (r: any) => any,
-        transformError = (r: any) => r
-    ): Promise<Response> {
-        return this.provider.execute({
-            uri,
-            verb: HttpVerb.Post,
-            body,
-            transform,
-            transformError,
-            options: this.options(HttpVerb.Post, options)
-        });
-    }
+  post(uri: Uri, body?: unknown, options: RouteOptions = RequestOptions.Json, transform?: (r: any) => any, transformError = (r: any) => r): Promise<Response> {
+    return this.execute({
+      uri,
+      verb: HttpVerb.Post,
+      body,
+      transform,
+      transformError,
+      options: this.options(HttpVerb.Post, options),
+    });
+  }
 
-    put(uri: Uri, body?: unknown, options: RouteOptions = RequestOptions.Json, transform?: (r: any) => any, transformError = (r: any) => r): Promise<Response> {
-        return this.provider.execute({
-            uri,
-            verb: HttpVerb.Put,
-            body,
-            transform,
-            transformError,
-            options: this.options(HttpVerb.Put, options)
-        });
-    }
+  put(uri: Uri, body?: unknown, options: RouteOptions = RequestOptions.Json, transform?: (r: any) => any, transformError = (r: any) => r): Promise<Response> {
+    return this.execute({
+      uri,
+      verb: HttpVerb.Put,
+      body,
+      transform,
+      transformError,
+      options: this.options(HttpVerb.Put, options),
+    });
+  }
 
-    patch(
-        uri: Uri,
-        body?: unknown,
-        options: RouteOptions = RequestOptions.Json,
-        transform?: (r: any) => any,
-        transformError = (r: any) => r
-    ): Promise<Response> {
-        return this.provider.execute({
-            uri,
-            verb: HttpVerb.Patch,
-            body,
-            transform,
-            transformError,
-            options: this.options(HttpVerb.Patch, options)
-        });
-    }
+  patch(uri: Uri, body?: unknown, options: RouteOptions = RequestOptions.Json, transform?: (r: any) => any, transformError = (r: any) => r): Promise<Response> {
+    return this.execute({
+      uri,
+      verb: HttpVerb.Patch,
+      body,
+      transform,
+      transformError,
+      options: this.options(HttpVerb.Patch, options),
+    });
+  }
 
-    delete(uri: Uri, options: RouteOptions = RequestOptions.Json, transform?: (b: any) => any, transformError = (r: any) => r): Promise<Response> {
-        return this.provider.execute({
-            uri,
-            verb: HttpVerb.Delete,
-            transform,
-            transformError,
-            options: this.options(HttpVerb.Delete, options)
-        });
-    }
+  delete(uri: Uri, options: RouteOptions = RequestOptions.Json, transform?: (b: any) => any, transformError = (r: any) => r): Promise<Response> {
+    return this.execute({
+      uri,
+      verb: HttpVerb.Delete,
+      transform,
+      transformError,
+      options: this.options(HttpVerb.Delete, options),
+    });
+  }
 
-    options(verb: HttpVerb, options?: RouteOptions): RequestOptions {
-        return options instanceof RequestOptions ? options : RequestOptions.Json;
-    }
+  options(verb: HttpVerb, options?: RouteOptions): RequestOptions {
+    return options instanceof RequestOptions ? options : RequestOptions.Json;
+  }
+
+  execute = (req: Request): Promise<Response> => (this.store ? this.store.execute(req, () => this.provider.execute(req)) : this.provider.execute(req));
 }
 
 export const api: Api = new Api();

package/src/services/RouteGateway.ts

@@ -1,81 +1,91 @@
-import {Api, RouteOptions} from './Api';
-import {FetchOptions, Filter, Func, Gateway, Id, Json, JsonValue, PageList, toPageList, Uri} from '../types';
-import {HttpStatus, RequestOptions, toPageOptions} from '../http';
+import { Api, RouteOptions } from './Api';
+import { FetchOptions, Filter, Func, Gateway, Id, Json, JsonValue, PageList, toPageList, Uri } from '../types';
+import { HttpStatus, RequestOptions, toPageOptions } from '../http';
 
 export class RouteGateway extends Gateway<RouteOptions> {
-    constructor(readonly route: Func<Uri>, readonly routeId: Func<Uri>, readonly api: Api = new Api()) {
-        super();
-    }
-
-    get(uri: Uri, options?: RouteOptions): Promise<PageList<Json>> {
-        return this.api.get(uri, options).then(r => toPageList<Json>(r.body.data?.items, toPageOptions(options) && {
-            total: r.body.data?.totalItems,
-            filters: r.body.data?.meta?.filters as Filter[],
-        }));
-    }
-
-    getOne(uri: Uri, options?: RouteOptions): Promise<Json | undefined> {
-        return this.get(uri, options).then(r => r.first());
-    }
-
-    all(options?: RouteOptions): Promise<PageList<Json>> {
-        return this.get(this.route(), options);
-    }
-
-    byId(id: Id, options?: RouteOptions): Promise<Json | undefined> {
-        return this.getOne(this.routeId().id(id));
-    }
-
-    search(q: JsonValue, options?: RouteOptions): Promise<PageList<Json>> {
-        return this.get(this.route().query(q), options);
-    }
-
-    exists(id: Id, options?: RouteOptions): Promise<boolean> {
-        return this.get(this.routeId().id(id))
-            .then(r => r.length === 1)
-            .catch(r => (HttpStatus.NotFound.equals(r.status) ? false : Promise.reject(r)));
-    }
-
-    add(item: Json, options?: RouteOptions): Promise<Json> {
-        return this.post(this.route(), item);
-    }
-
-    filter(options?: RouteOptions): Promise<PageList<Json>> {
-        return this.postSearch(this.route(), options);
-    }
-
-    update(item: Json, options?: RouteOptions): Promise<Json> {
-        return this.patch(this.routeId().id(item.id), item);
-    }
-
-    upsert(item: Json, options?: RouteOptions): Promise<Json> {
-        return this.put(this.routeId().id(item.id), item);
-    }
-
-    remove(id: Id, options?: RouteOptions): Promise<boolean> {
-        return this.delete(this.routeId().id(id));
-    }
-
-    post(uri: Uri, item?: Json): Promise<Json> {
-        return this.api.post(uri, item).then(r => r.body.data?.items.first() ?? {});
-    }
-
-    postSearch(uri: Uri, options?: RequestOptions | FetchOptions): Promise<PageList<Json>> {
-        return this.api.post(uri, options).then(r => toPageList<Json>(r.body.data?.items, toPageOptions(options) && {
-            total: r.body.data?.totalItems,
-            filters: r.body.data?.meta?.filters as Filter[],
-        }));
-    }
-
-    patch(uri: Uri, item: Json): Promise<Json> {
-        return this.api.patch(uri, item).then(r => r.body.data?.items.first() ?? {});
-    }
-
-    put(uri: Uri, item: Json): Promise<Json> {
-        return this.api.put(uri, item).then(r => r.body.data?.items.first() ?? {});
-    }
-
-    delete(uri: Uri, options?: RouteOptions): Promise<boolean> {
-        return this.api.delete(uri).then(() => true);
-    }
+  constructor(readonly route: Func<Uri>, readonly routeId: Func<Uri>, readonly api: Api = new Api()) {
+    super();
+  }
+
+  get(uri: Uri, options?: RouteOptions): Promise<PageList<Json>> {
+    return this.api.get(uri, options).then(r =>
+      toPageList<Json>(
+        r.body.data?.items,
+        toPageOptions(options) && {
+          total: r.body.data?.totalItems,
+          filters: r.body.data?.meta?.filters as Filter[],
+        }
+      )
+    );
+  }
+
+  getOne(uri: Uri, options?: RouteOptions): Promise<Json | undefined> {
+    return this.get(uri, options).then(r => r.first());
+  }
+
+  all(options?: RouteOptions): Promise<PageList<Json>> {
+    return this.get(this.route(), options);
+  }
+
+  byId(id: Id, options?: RouteOptions): Promise<Json | undefined> {
+    return this.getOne(this.routeId().id(id));
+  }
+
+  search(q: JsonValue, options?: RouteOptions): Promise<PageList<Json>> {
+    return this.get(this.route().query(q), options);
+  }
+
+  exists(id: Id, options?: RouteOptions): Promise<boolean> {
+    return this.get(this.routeId().id(id))
+      .then(r => r.length === 1)
+      .catch(r => (HttpStatus.NotFound.equals(r.status) ? false : Promise.reject(r)));
+  }
+
+  add(item: Json, options?: RouteOptions): Promise<Json> {
+    return this.post(this.route(), item, options);
+  }
+
+  filter(options?: RouteOptions): Promise<PageList<Json>> {
+    return this.postSearch(this.route(), options);
+  }
+
+  update(item: Json, options?: RouteOptions): Promise<Json> {
+    return this.patch(this.routeId().id(item.id), item, options);
+  }
+
+  upsert(item: Json, options?: RouteOptions): Promise<Json> {
+    return this.put(this.routeId().id(item.id), item, options);
+  }
+
+  remove(id: Id, options?: RouteOptions): Promise<boolean> {
+    return this.delete(this.routeId().id(id), options);
+  }
+
+  post(uri: Uri, item?: Json, options?: RouteOptions): Promise<Json> {
+    return this.api.post(uri, item, options).then(r => r.body.data?.items.first() ?? {});
+  }
+
+  postSearch(uri: Uri, options?: RequestOptions | FetchOptions): Promise<PageList<Json>> {
+    return this.api.post(uri, options).then(r =>
+      toPageList<Json>(
+        r.body.data?.items,
+        toPageOptions(options) && {
+          total: r.body.data?.totalItems,
+          filters: r.body.data?.meta?.filters as Filter[],
+        }
+      )
+    );
+  }
+
+  patch(uri: Uri, item: Json, options?: RouteOptions): Promise<Json> {
+    return this.api.patch(uri, item, options).then(r => r.body.data?.items.first() ?? {});
+  }
+
+  put(uri: Uri, item: Json, options?: RouteOptions): Promise<Json> {
+    return this.api.put(uri, item, options).then(r => r.body.data?.items.first() ?? {});
+  }
+
+  delete(uri: Uri, options?: RouteOptions): Promise<boolean> {
+    return this.api.delete(uri, options).then(() => true);
+  }
 }

package/src/types/Cache.ts

@@ -1,12 +1,24 @@
-import {Func} from "./Func";
-import {CacheAge} from "./CacheAge";
-import {Construct} from "./Constructor";
+import { Func } from './Func';
+import { CacheAge } from './CacheAge';
+import { Construct } from './Constructor';
+import { meta } from './Meta';
 
 export interface Store<To = any, From = any> {
-    execute: (fetch: From, f: Func<Promise<To>, From>) => Promise<To>;
+  execute: (fetch: From, f: Func<Promise<To>, From>) => Promise<To>;
 }
 
 export type CacheOptions = {
-    expiresIn?: CacheAge;
-    store?: Construct<Store>;
+  expiresIn?: CacheAge;
+  store?: Construct<Store>;
 };
+
+export const toCacheOptions = (co: Partial<CacheOptions>): CacheOptions => ({
+  expiresIn: co.expiresIn ?? '5m',
+  store: co.store,
+});
+
+export const cache =
+  (options: Partial<CacheOptions>): ClassDecorator =>
+  (subject: unknown): void => {
+    meta(subject).set('cache', toCacheOptions(options));
+  };

package/src/types/CacheAge.ts

@@ -1,55 +1,55 @@
-import {asNumber, asString, choose} from "./index";
+import { asNumber, asString, choose } from './index';
 
 export type CacheAge = `${number}${'ms' | 's' | 'm' | 'h' | 'd'}` | number;
 
 const ageNumber = (s: string): number => asNumber(s.replace(/[a-z]/g, ''));
 
 export const cacheAge = {
-    toMilliseconds: (ca: CacheAge): number =>
-        choose(asString(ca))
-            .case(
-                c => c.endsWith('ms'),
-                c => ageNumber(c)
-            )
-            .case(
-                c => c.endsWith('s'),
-                c => ageNumber(c) * 1000
-            )
-            .case(
-                c => c.endsWith('m'),
-                c => ageNumber(c) * 60 * 1000
-            )
-            .case(
-                c => c.endsWith('h'),
-                c => ageNumber(c) * 3600 * 1000
-            )
-            .case(
-                c => c.endsWith('d'),
-                c => ageNumber(c) * 24 * 3600 * 1000
-            )
-            .else(ca as number),
+  toMilliseconds: (ca: CacheAge): number =>
+    choose(asString(ca))
+      .case(
+        c => c.endsWith('ms'),
+        c => ageNumber(c)
+      )
+      .case(
+        c => c.endsWith('s'),
+        c => ageNumber(c) * 1000
+      )
+      .case(
+        c => c.endsWith('m'),
+        c => ageNumber(c) * 60 * 1000
+      )
+      .case(
+        c => c.endsWith('h'),
+        c => ageNumber(c) * 3600 * 1000
+      )
+      .case(
+        c => c.endsWith('d'),
+        c => ageNumber(c) * 24 * 3600 * 1000
+      )
+      .else(ca as number),
 
-    toSeconds: (ca: CacheAge): number =>
-        choose(asString(ca))
-            .case(
-                c => c.endsWith('ms'),
-                c => ageNumber(c) / 1000
-            )
-            .case(
-                c => c.endsWith('s'),
-                c => ageNumber(c)
-            )
-            .case(
-                c => c.endsWith('m'),
-                c => ageNumber(c) * 60
-            )
-            .case(
-                c => c.endsWith('h'),
-                c => ageNumber(c) * 3600
-            )
-            .case(
-                c => c.endsWith('d'),
-                c => ageNumber(c) * 24 * 3600
-            )
-            .else(ca as number)
-}
+  toSeconds: (ca: CacheAge): number =>
+    choose(asString(ca))
+      .case(
+        c => c.endsWith('ms'),
+        c => ageNumber(c) / 1000
+      )
+      .case(
+        c => c.endsWith('s'),
+        c => ageNumber(c)
+      )
+      .case(
+        c => c.endsWith('m'),
+        c => ageNumber(c) * 60
+      )
+      .case(
+        c => c.endsWith('h'),
+        c => ageNumber(c) * 3600
+      )
+      .case(
+        c => c.endsWith('d'),
+        c => ageNumber(c) * 24 * 3600
+      )
+      .else(ca as number),
+};

package/src/types/Constructor.ts

@@ -13,6 +13,6 @@ export const ofConstruct = <T>(c: Construct<T>, ...args: unknown[]): T => (isCon
 export const toName = (subject?: unknown, postfix = ''): string => (subject as any)?.constructor?.name?.replace(postfix, '').toLowerCase() ?? '';
 
 export const on = <T>(t: T, f: (t: T) => unknown): T => {
-    f(t);
-    return t;
-};
+  f(t);
+  return t;
+};

package/src/types/Gateway.ts

@@ -4,10 +4,8 @@ import { Exception } from './Exception';
 import { reject } from '../utils';
 import { PageList, PageOptions } from './PageList';
 import { List } from './List';
-import {CacheOptions} from "./Cache";
 
-
-export type FetchOptions = PageOptions & CacheOptions;
+export type FetchOptions = PageOptions;
 
 export abstract class Gateway<Options = FetchOptions> {
   all(options?: Options): Promise<PageList<Json>> {

package/src/types/List.ts

@@ -7,6 +7,7 @@ import { Get, GetProperty, ofGet, ofProperty } from './Get';
 import { Id } from './Id';
 import { asString } from './Text';
 import { tryTo } from './Try';
+import { meta } from './Meta';
 
 export class List<T = unknown> extends Array<T> {
   asc = (p: GetProperty<T, any>): List<T> => this.sort((e1, e2) => (ofProperty(e1, p) > ofProperty(e2, p) ? 1 : -1));
@@ -54,6 +55,8 @@ export class List<T = unknown> extends Array<T> {
 
   distinct = (): List<T> => this.filter((i, index) => this.indexOf(i) === index);
 
+  distinctByKey = (key: keyof T): List<T> => meta(this.toObject(key)).values();
+
   filter = (p: (value: T, index: number, array: T[]) => unknown, params?: unknown): List<T> => toList<T>(super.filter(p, params));
 
   sum = (p: (t: T) => number): number => this.reduce((sum: number, i) => sum + p(i), 0);
@@ -77,7 +80,7 @@ export class List<T = unknown> extends Array<T> {
     tryTo(() => item[key])
       .map(k => this.findIndex(i => i[key] === k))
       .filter(i => i > -1)
-      .map(i => this[i] = item);
+      .map(i => (this[i] = item));
     return this;
   };
 

package/src/types/PageList.ts

@@ -2,7 +2,7 @@ import { isList, List, toList } from './List';
 import { Construct, ofConstruct } from './Constructor';
 import { isA } from './IsA';
 
-export type Sort =  { key: string; value: -1 | 1 };
+export type Sort = { key: string; value: -1 | 1 };
 
 export type FilterValue = { label?: string; value: any };
 export type Filter = { label?: string; field: string; values: FilterValue[] };
@@ -26,5 +26,5 @@ export const toPageList = <T>(items?: T[], options?: Omit<PageOptions, 'sort'> &
 export const asPageList = <T, U>(c: Construct<T>, items = toPageList<U>()): PageList<T> =>
   toPageList<T>(
     items.map(i => ofConstruct(c, i)),
-    items,
+    items
   );

package/src/types/Repository.ts

@@ -0,0 +1,52 @@
+import { Exception, Id, Json, JsonValue, Key, List, PageList, PageOptions } from './index';
+import { reject } from '../utils';
+
+export class Repository<T> {
+  all(options?: PageOptions): Promise<PageList<T>> {
+    return reject(Exception.IsNotImplemented);
+  }
+
+  byId(id: Id): Promise<T> {
+    return reject(Exception.IsNotImplemented);
+  }
+
+  byIds(...ids: Id[]): Promise<List<T>> {
+    return reject(Exception.IsNotImplemented);
+  }
+
+  byKey(key: Key, options?: PageOptions): Promise<PageList<T>> {
+    return reject(Exception.IsNotImplemented);
+  }
+
+  by(key: keyof T, value: JsonValue, options?: PageOptions): Promise<PageList<T>> {
+    return reject(Exception.IsNotImplemented);
+  }
+
+  search(q: JsonValue, options?: PageOptions): Promise<PageList<T>> {
+    return reject(Exception.IsNotImplemented);
+  }
+
+  filter(options?: PageOptions): Promise<PageList<T>> {
+    return reject(Exception.IsNotImplemented);
+  }
+
+  exists(id: Id): Promise<boolean> {
+    return reject(Exception.IsNotImplemented);
+  }
+
+  add(t: T | Json): Promise<T> {
+    return reject(Exception.IsNotImplemented);
+  }
+
+  update(id: Id, json: Json): Promise<T> {
+    return reject(Exception.IsNotImplemented);
+  }
+
+  remove(id: Id): Promise<boolean> {
+    return reject(Exception.IsNotImplemented);
+  }
+
+  upsert(id: Id, item: Json): Promise<T> {
+    return reject(Exception.IsNotImplemented);
+  }
+}

package/src/types/Types.ts

@@ -1,2 +1 @@
-
 export type DontInfer<T> = [T][T extends any ? 0 : never];

package/src/types/Uri.ts

@@ -8,19 +8,19 @@ import { tryTo } from './Try';
 
 export type Segment = Text & { key?: string; segment?: string; query?: (value: unknown) => string };
 
-const toSegment = (key?: string, { segment, query }: { segment?: string; query?: (value: unknown) => string } = {}): Segment => ({
-  key,
+const toSegment = (key?: Text, { segment, query }: { segment?: string; query?: (value: unknown) => string } = {}): Segment => ({
+  key: asString(key),
   segment,
   query,
-  toString: () => key ?? '',
+  toString: () => asString(key),
 });
 
 export const uri = {
   host: (key?: string): Segment => toSegment(key, { segment: key ?? ctx.env.host ?? '$host' }),
   resource: (resource: Uri): Segment => toSegment(toName(resource, 'Uri'), { segment: toName(resource, 'Uri') }),
-  segment: (key?: string): Segment => toSegment(key, { segment: key }),
-  path: (key: string): Segment => toSegment(key, { segment: `:${key}` }),
-  query: (key: string): Segment => toSegment(key, { query: (value: unknown): string => (isDefined(value) ? `${key}=${value}` : '') }),
+  segment: (key?: Text): Segment => toSegment(key, { segment: asString(key) }),
+  path: (key: Text): Segment => toSegment(key, { segment: `:${key}` }),
+  query: (key: Text): Segment => toSegment(key, { query: (value: unknown): string => (isDefined(value) ? `${key}=${value}` : '') }),
 };
 
 type Prop = { segment: Segment; value: any };

package/src/types/index.ts

@@ -22,6 +22,7 @@ export * from './List';
 export * from './Message';
 export * from './Meta';
 export * from './Number';
+export * from './Repository';
 export * from './Result';
 export * from './Results';
 export * from './Tag';

package/src/utils/View.ts

@@ -36,9 +36,9 @@ const toFunc = (a: any, col: string, f: Func = a => a): Func =>
 const toViewer = (key: string, value: unknown): Viewer =>
   choose(value)
     .is.not.defined(
-    v => v,
-    () => toViewer(key, () => undefined),
-  )
+      v => v,
+      () => toViewer(key, () => undefined)
+    )
     .type(isBoolean, b => toViewer(key, () => b))
     .type(isNumber, n => toViewer(key, () => n))
     .type(isString, s => toViewer(key, (a: any) => toFunc(a, s)(a)))
@@ -55,15 +55,13 @@ const toViewers = (views: Views): Viewer[] =>
     .map(([k, v]) => toViewer(k, v));
 
 export class View<V = Json> {
-  constructor(private views: Views<V> = {} as Views<V>, readonly startsFrom: 'scratch' | 'source' = 'scratch', readonly viewers: Viewer[] = toViewers(views)) {
-  }
+  constructor(private views: Views<V> = {} as Views<V>, readonly startsFrom: 'scratch' | 'source' = 'scratch', readonly viewers: Viewer[] = toViewers(views)) {}
 
   get fromSource(): View<V> {
     return new View(this.views, 'source', this.viewers);
   }
 
-  from = <T = unknown>(source: T | T[]): T extends [] ? V[] : V =>
-    isArray(source) ? source.map(s => this.reduce(asJson(s))) : this.reduce(asJson(source));
+  from = <T = unknown>(source: T | T[]): T extends [] ? V[] : V => (isArray(source) ? source.map(s => this.reduce(asJson(s))) : this.reduce(asJson(source)));
 
   same = (one?: unknown, another?: unknown): boolean => isEqual(this.from(one), this.from(another));
 
@@ -80,11 +78,11 @@ export const views = {
   keepOr: (alt?: string) => (a: unknown, key?: string) => traverse(a, key) ?? alt,
   or:
     (key: string, alt = '') =>
-      (a: unknown) =>
-        traverse(a, key) ?? alt,
+    (a: unknown) =>
+      traverse(a, key) ?? alt,
   value: (value: unknown) => () => value,
   to:
     <T>(ctor: Constructor<T>) =>
-      (a: unknown, key?: string) =>
-        new ctor(traverse(a, key)),
+    (a: unknown, key?: string) =>
+      new ctor(traverse(a, key)),
 };