@websolutespa/bom-mixer-store 1.2.2 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@websolutespa/bom-mixer-store",
-  "version": "1.2.2",
+  "version": "1.3.0",
   "description": "Mixer Store module of the BOM Repository",
   "keywords": [
     "bom",

package/src/mock/mock-menu.service.ts

@@ -1,10 +1,12 @@
 import {
-  ICategorized, ICategory, IEntity, IEquatable, IMenu, IMenuCategory, IMenuGroup, IMenuItem,
+  ICategorized, ICategory, IEntity,
+  IMenu, IMenuCategory, IMenuGroup, IMenuItem,
   IMenuLink, IMenuPage, IMenuRoute, IRoute, IStore,
   IUndecoratedMenu, IUndecoratedMenuCategory, IUndecoratedMenuGroup, IUndecoratedMenuItem,
-  IUndecoratedMenuLink, IUndecoratedMenuPage, Pagination, QueryParams, localizeItem
+  IUndecoratedMenuLink, IUndecoratedMenuPage,
+  QueryParams
 } from '@websolutespa/bom-core';
-import { MockService } from './mock.service';
+import { MockService, localizeItem_, localizeItems_ } from './mock.service';
 
 export const MAX_INT = 1000000000000; // 9007199254740991
 
@@ -12,11 +14,15 @@ let UID = 0;
 
 export class MockMenuService<T extends IEntity = IEntity> extends MockService<T> {
 
+  /*
   async findOne<B extends T = T>(id: IEquatable, params: QueryParams = {}): Promise<B | undefined> {
     // console.log('MockMenuService.findOne', id, params);
     let item = await super.findOne<B>(id, params);
     if (item && params.market && params.locale) {
-      item = await decorateMenu(this.store, (item as any), params.market, params.locale) as any;
+      item = await decorateMenu_(this.store, (item as any), {
+        market: params.market,
+        locale: params.locale,
+      }) as any;
     }
     return item;
   }
@@ -25,7 +31,10 @@ export class MockMenuService<T extends IEntity = IEntity> extends MockService<T>
     // console.log('MockMenuService.findMany', params);
     let items = await super.findMany<B>(params);
     if (params.market && params.locale) {
-      items = await decorateMenus(this.store, (items as any[]), params.market, params.locale) as any[];
+      items = await decorateMenus_(this.store, (items as any[]), {
+        market: params.market,
+        locale: params.locale,
+      }) as any[];
     }
     return items;
   }
@@ -34,20 +43,40 @@ export class MockMenuService<T extends IEntity = IEntity> extends MockService<T>
     // console.log('MockMenuService.findPaged', params);
     const pagination = await super.findPaged<B>(params);
     if (params.market && params.locale) {
-      pagination.docs = await decorateMenus(this.store, (pagination.docs as any[]), params.market, params.locale) as any[];
+      pagination.docs = await decorateMenus_(this.store, (pagination.docs as any[]), {
+        market: params.market,
+        locale: params.locale,
+      }) as any[];
     }
     return pagination;
   }
+  */
 
-  protected override decorator_<B extends T = T>(item: B, params: QueryParams = {}): B {
-    if (params.locale) {
-      return localizeItem(item, params.locale);
-    } else {
-      return item;
+  protected override async decorateOne_<B extends T = T>(item: B, params: QueryParams = {}): Promise<B> {
+    let decoratedItem = await localizeItem_(item, params);
+    // decoratedItem = await decorateHref_<B>(this.store, decoratedItem, params);
+    if (params.market && params.locale) {
+      decoratedItem = await decorateMenu_(this.store, decoratedItem as any as IUndecoratedMenu, {
+        market: params.market,
+        locale: params.locale,
+      }) as any;
     }
+    return decoratedItem;
+  }
+
+  protected override async decorateMany_<B extends T = T>(items: B[], params: QueryParams = {}): Promise<B[]> {
+    let decoratedItems = await localizeItems_(items, params);
+    // decoratedItems = await decorateHrefs_<B>(this.store, decoratedItems, params);
+    if (params.market && params.locale) {
+      decoratedItems = await decorateMenus_(this.store, decoratedItems as any as IUndecoratedMenu[], {
+        market: params.market,
+        locale: params.locale,
+      }) as any[];
+    }
+    return decoratedItems;
   }
-}
 
+}
 
 async function collectPages(store: IStore, items?: IUndecoratedMenuItem[], params: QueryParams = {}) {
   if (!items) {
@@ -65,6 +94,8 @@ async function collectPages(store: IStore, items?: IUndecoratedMenuItem[], param
       if (value) {
         const routes = await store.route.findMany<IRoute>({
           where: {
+            ...(params.market ? { market: { equals: params.market } } : {}),
+            ...(params.locale ? { locale: { equals: params.locale } } : {}),
             page: {
               equals: item.page.value,
             },
@@ -72,8 +103,6 @@ async function collectPages(store: IStore, items?: IUndecoratedMenuItem[], param
               equals: item.page.relationTo,
             },
           },
-          market: params.market,
-          locale: params.locale,
         });
         const page = {
           ...value,
@@ -92,31 +121,34 @@ async function collectPages(store: IStore, items?: IUndecoratedMenuItem[], param
   }
 }
 
-export async function decorateMenu(store: IStore, item: IUndecoratedMenu, market: string = 'ww', locale: string = 'en'): Promise<IMenu> {
+export async function decorateMenu_(store: IStore, item: IUndecoratedMenu, params: { market: string, locale: string }): Promise<IMenu> {
   const items = item.items || [];
   const decoratedItem: IMenu = {
     id: item.id,
     items: [],
   };
-  const categories = await store.category.findMany<ICategory>({ market, locale });
+  const categories = await store.category.findMany<ICategory>(params);
   const routes = await store.route.findMany<IRoute>({
+    ...params,
     where: {
-      market: {
-        equals: market,
-      },
-      locale: {
-        equals: locale,
-      },
+      ...(params.market ? { market: { equals: params.market } } : {}),
+      ...(params.locale ? { locale: { equals: params.locale } } : {}),
     },
-    market, locale,
   });
-  await collectPages(store, items, { market, locale });
-  decoratedItem.items = items.filter(x => hasMarket(x, market)).map(x => decorateMenuItem(x, categories, routes, market));
+  await collectPages(store, items, params);
+  decoratedItem.items = items
+    .filter(x => hasMarket(x, params.market))
+    .map(x => decorateMenuItem(x, categories, routes, params.market));
   return decoratedItem;
 }
 
-export async function decorateMenus(store: IStore, items: IUndecoratedMenu[], market: string = 'ww', locale: string = 'en'): Promise<IMenu[]> {
-  return await Promise.all(items.map(x => decorateMenu(store, x, market, locale)));
+export async function decorateMenus_(store: IStore, items: IUndecoratedMenu[], params: { market: string, locale: string }): Promise<IMenu[]> {
+  const decoratedItems: IMenu[] = [];
+  for (const item of items) {
+    const decoratedItem = await decorateMenu_(store, item, params);
+    decoratedItems.push(decoratedItem);
+  }
+  return decoratedItems;
 }
 
 export function decorateMenuCategory(
@@ -251,7 +283,10 @@ export function decorateMenuPage(
   market: string
 ): IMenuItem {
   const items = item.items || [];
-  const route = routes.find(x => x.schema === item.page.relationTo && x.page === item.page.value.id);
+  const route = routes.find(x =>
+    x.schema === item.page.relationTo &&
+    x.page === item.page.value.id
+  );
   const decoratedItem: IMenuPage = {
     id: item.id || '',
     type: item.type,

package/src/mock/mock-page.service.ts

@@ -1,75 +1,154 @@
-import { IEntity, IEquatable, IRoute, ISchema, IStore, Pagination, QueryParams, localizeItem } from '@websolutespa/bom-core';
-import { MockService } from './mock.service';
+import { IDecoratedNav, IEntity, IEquatable, IMenuPage, IRoute, ISchema, IStore, IUndecoratedNav, QueryParams, isArray, isObject, isUndecoratedNav } from '@websolutespa/bom-core';
+import { MockService, decorateRelation_, decorateRelations_, localizeItem_, localizeItems_ } from './mock.service';
 
 export class MockPageService<T extends IEntity = IEntity> extends MockService<T> {
 
-  async findOne<B extends T = T>(id: IEquatable, params: QueryParams = {}): Promise<B | undefined> {
-    // console.log('MockPageService.findOne', id, params);
-    let item = await super.findOne<B>(id, params);
-    if (item && params.market && params.locale) {
-      item = await decorateHref<B>(this.store, item, params.market, params.locale);
-    }
+  protected override async decorateOne_<B extends T = T>(item: B, params: QueryParams = {}): Promise<B> {
+    let decoratedItem = await localizeItem_(item, params);
+    decoratedItem = await decorateHref_<B>(this.store, decoratedItem, params);
+    decoratedItem = await decorateNav_<B>(this.store, decoratedItem, params);
+    decoratedItem = await decorateRelation_<B>(this.store, decoratedItem, {
+      market: params.market,
+      locale: params.locale,
+      depth: params.depth,
+    });
+    return decoratedItem;
+  }
+
+  protected override async decorateMany_<B extends T = T>(items: B[], params: QueryParams = {}): Promise<B[]> {
+    let decoratedItems = await localizeItems_(items, params);
+    decoratedItems = await decorateHrefs_<B>(this.store, decoratedItems, params);
+    decoratedItems = await decorateNavs_<B>(this.store, decoratedItems, params);
+    decoratedItems = await decorateRelations_<B>(this.store, decoratedItems, {
+      market: params.market,
+      locale: params.locale,
+      depth: params.depth,
+    });
+    return decoratedItems;
+  }
+
+}
+
+export async function decorateHref_<T extends ISchema = ISchema>(store: IStore, item: T, params: QueryParams = {}): Promise<T | T & { href: string | null }> {
+  if (params.market && params.locale) {
+    const routes = await store.route.findMany<IRoute>({
+      where: {
+        market: {
+          equals: params.market,
+        },
+        locale: {
+          equals: params.locale,
+        },
+        schema: {
+          equals: item.schema,
+        },
+        page: {
+          equals: item.id,
+        },
+      },
+    });
+    const href = routes.length ? routes[0].id : null;
+    return { ...item, href };
+  } else {
     return item;
   }
+}
 
-  async findMany<B extends T = T>(params: QueryParams = {}): Promise<B[]> {
-    // console.log('MockPageService.findMany', params);
-    let items = await super.findMany<B>(params);
-    if (params.market && params.locale) {
-      items = await decorateHrefs<B>(this.store, items, params.market, params.locale);
-    }
+export async function decorateHrefs_<T extends ISchema = ISchema>(store: IStore, items: T[], params: QueryParams = {}): Promise<T[] | (T & { href: string | null })[]> {
+  if (params.market && params.locale) {
+    const routes = await store.route.findMany<IRoute>({
+      where: {
+        market: {
+          equals: params.market,
+        },
+        locale: {
+          equals: params.locale,
+        },
+        /*
+        ...(params.market ? { market: { equals: params.market } } : {}),
+        ...(params.locale ? { locale: { equals: params.locale } } : {}),
+        */
+      },
+    });
+    return items.map(item => {
+      const route = routes.find(x =>
+        x.schema === item.schema &&
+        x.page === item.id
+      );
+      const href = route ? route.id : null;
+      return { ...item, href };
+    });
+  } else {
     return items;
   }
+}
 
-  async findPaged<B extends T = T>(params: QueryParams = {}): Promise<{ docs: B[]; } & Pagination> {
-    // console.log('MockPageService.findPaged', params);
-    const pagination = await super.findPaged<B>(params);
-    if (params.market && params.locale) {
-      pagination.docs = await decorateHrefs<B>(this.store, pagination.docs, params.market, params.locale);
-    }
-    return pagination;
+export async function decorateNav_<T extends ISchema = ISchema>(store: IStore, item: T, params: QueryParams = {}, routes?: IRoute[]): Promise<T> {
+  if (!routes) {
+    routes = await store.route.findMany<IRoute>({
+      where: {
+        ...(params.market ? { market: { equals: params.market } } : {}),
+        ...(params.locale ? { locale: { equals: params.locale } } : {}),
+      },
+    });
   }
-
-  protected override decorator_<B extends T = T>(item: B, params: QueryParams = {}): B {
-    if (params.locale) {
-      return localizeItem(item, params.locale);
-    } else {
-      return item;
-    }
+  const navs = collectNavs_(item);
+  for (const nav of navs) {
+    const decoratedNav = decorateNav__(nav, routes);
+    (nav as IDecoratedNav<T>).nav = decoratedNav.nav;
   }
+  return item;
 }
 
-export async function decorateHref<T extends ISchema = ISchema>(store: IStore, item: T, market: string = 'ww', locale: string = 'en'): Promise<T & { href: string | null }> {
+export async function decorateNavs_<T extends ISchema = ISchema>(store: IStore, items: T[], params: QueryParams = {}): Promise<T[]> {
   const routes = await store.route.findMany<IRoute>({
+    ...params,
     where: {
-      schema: {
-        equals: item.schema
-      },
-      page: {
-        equals: item.id
-      },
-      market: {
-        equals: market
-      },
-      locale: {
-        equals: locale
-      },
-    }
+      ...(params.market ? { market: { equals: params.market } } : {}),
+      ...(params.locale ? { locale: { equals: params.locale } } : {}),
+    },
   });
-  const href = routes.length ? routes[0].id : null;
-  return { ...item, href };
+  for (const item of items) {
+    await decorateNav_<T>(store, item, params, routes);
+  }
+  return items;
 }
 
-export async function decorateHrefs<T extends ISchema = ISchema>(store: IStore, items: T[], market: string = 'ww', locale: string = 'en'): Promise<(T & { href: string | null })[]> {
-  const routes = await store.route.findMany<IRoute>();
-  return items.map(item => {
+// collecting navs recursively
+function collectNavs_<T>(item: unknown, navs: IUndecoratedNav<T>[] = []): IUndecoratedNav<T>[] {
+  if (isUndecoratedNav<T>(item)) {
+    navs.push(item);
+  }
+  // console.log(item, isUndecoratedNav<T>(item));
+  if (isArray(item)) {
+    item.forEach(x => collectNavs_(x, navs));
+  } else if (isObject(item)) {
+    Object.values(item).forEach(value => {
+      collectNavs_(value, navs);
+    });
+  }
+  return navs;
+}
+
+function decorateNav__<T>(item: IUndecoratedNav<T>, routes: IRoute[]): IDecoratedNav<T> {
+  const { nav, ...undecorated } = item;
+  if (nav !== undefined) {
+    const decorated = { ...undecorated } as { nav?: IMenuPage };
     const route = routes.find(x =>
-      x.schema === item.schema &&
-      x.page === item.id &&
-      x.market === market &&
-      x.locale === locale
+      x.page === (nav.page.value as unknown as IEquatable) &&
+      x.schema === nav.page.relationTo
     );
-    const href = route ? route.id : null;
-    return { ...item, href };
-  });
+    if (route) {
+      decorated.nav = {
+        type: 'page',
+        id: route.id,
+        href: route.id,
+        title: route.title,
+        page: (nav.page.value as unknown as IEquatable),
+        schema: nav.page.relationTo,
+      };
+    }
+    return decorated as IDecoratedNav<T>;
+  }
+  return undecorated as IDecoratedNav<T>;
 }

package/src/mock/mock.service.ts

@@ -1,4 +1,6 @@
-import { IEntity, IPageRelation, IStore, JsonService, localizeItem, QueryParams } from '@websolutespa/bom-core';
+import { cloneItem, IEntity, IPageUnresolvedRelation, isArray, ISchema, isObject, IStore, isUnresolvedRelation, JsonService, localizeItem, QueryParams } from '@websolutespa/bom-core';
+
+export const MOCK_SERVICE_DEFAULT_DEPTH = 2;
 
 export class MockService<T extends IEntity = IEntity> extends JsonService<T> {
   store: IStore;
@@ -8,66 +10,139 @@ export class MockService<T extends IEntity = IEntity> extends JsonService<T> {
     this.store = store;
   }
 
-  // !!! todo handle relations
+  protected override async decorateOne_<B extends T = T>(item: B, params: QueryParams = {}): Promise<B> {
+    let decoratedItem = await localizeItem_(item, params);
+    decoratedItem = await decorateRelation_<B>(this.store, decoratedItem, {
+      market: params.market,
+      locale: params.locale,
+      depth: params.depth != null ? params.depth : MOCK_SERVICE_DEFAULT_DEPTH,
+    });
+    return decoratedItem;
+  }
 
-  /*
-  override async findOne<B extends T = T>(id: IEquatable, params: QueryParams = {}): Promise<B | undefined> {
-    console.log('MockService.findOne', id, params);
-    let item = await super.findOne<B>(id, params);
-    // relations
-    if (item) {
-      if (params.depth !== 0) {
-        item = await this.relatedItems_(item);
-      }
-    }
-    return item;
+  protected override async decorateMany_<B extends T = T>(items: B[], params: QueryParams = {}): Promise<B[]> {
+    let decoratedItems = await localizeItems_(items, params);
+    decoratedItems = await decorateRelations_<B>(this.store, decoratedItems, {
+      market: params.market,
+      locale: params.locale,
+      depth: params.depth != null ? params.depth : MOCK_SERVICE_DEFAULT_DEPTH,
+    });
+    return decoratedItems;
   }
 
-  override async findMany<B extends T = T>(params: QueryParams = {}): Promise<B[]> {
-    // console.log('MockService.findMany', params);
-    let items = await super.findMany<B>(params);
-    // relations
-    if (params.depth !== 0) {
-      items = await Promise.all(items.map(x => this.relatedItems_(x)));
-    }
-    return items;
+}
+
+export async function localizeItem_<B>(item: B, params: QueryParams = {}): Promise<B> {
+  if (params.locale) {
+    return localizeItem(item, params.locale);
+  } else {
+    return cloneItem(item);
   }
+}
+
+export async function localizeItems_<B>(items: B[], params: QueryParams = {}): Promise<B[]> {
+  const decoratedItems: B[] = [];
+  for (const item of items) {
+    const decoratedItem = params.locale ?
+      localizeItem(item, params.locale) :
+      cloneItem(item);
+    decoratedItems.push(decoratedItem);
+  }
+  return decoratedItems;
+}
+
 
-  override async findPaged<B extends T = T>(params: QueryParams = {}): Promise<{ docs: B[]; } & Pagination> {
-    // console.log('MockService.findPaged', params);
-    const pagination = await super.findPaged<B>(params);
-    // relations
-    if (params.depth !== 0) {
-      pagination.docs = await Promise.all(pagination.docs.map(x => this.relatedItems_(x)));
+// getting item relation !!!unused
+function getRelations_(item: Record<string, any>): IPageUnresolvedRelation[] {
+  const relations: IPageUnresolvedRelation[] = [];
+  if (isObject(item)) {
+    if (item.relation && isUnresolvedRelation(item.relation)) {
+      relations.push(item.relation);
     }
-    return pagination;
   }
+  return relations;
+}
 
-  protected async relatedItems_<B extends T = T>(item: B): Promise<B> {
-    const x = { ...item };
-    Object.entries(item).forEach(([k, v]) => {
-      if (isRelation(v)) {
-        console.log(k, v);
+// collecting relations recursively
+function collectRelations_(item: unknown, relations: IPageUnresolvedRelation[] = []): IPageUnresolvedRelation[] {
+  if (isObject(item)) {
+    Object.entries(item).forEach(([key, value]) => {
+      if (key === 'relation' && isUnresolvedRelation(value)) {
+        // skip circular reference
+        if (value.relationTo !== item.schema || value.value !== item.id) {
+          relations.push(value);
+        }
+      } else if (isArray(value)) {
+        value.forEach(x => collectRelations_(x, relations));
+      } else if (isObject(value)) {
+        collectRelations_(value, relations);
       }
     });
-    return x;
   }
-  */
+  return relations;
+}
 
-  protected override decorator_<B extends T = T>(item: B, params: QueryParams = {}): B {
-    if (params.locale) {
-      return localizeItem(item, params.locale);
-    } else {
-      return item;
+/*
+const RELATION_CACHE = new Map<IEquatable, IEntity>();
+
+export async function decorateRelation_<T extends ISchema = ISchema>(store: IStore, item: T, params: QueryParams = {}): Promise<T> {
+  const depth = params.depth != null ? params.depth : 0;
+  if (depth === 0) {
+    return item;
+  }
+  if (RELATION_CACHE.has(item.id)) {
+    return RELATION_CACHE.get(item.id) as T;
+  } else {
+    // item = await decorateRelation_<B>(this.store, item, params.market, params.locale);
+    const relations = collectRelations_(item);
+    for (const relation of relations) {
+      const isMany = Array.isArray(relation.value);
+      const items = await store[relation.relationTo].findMany({
+        ...params,
+        where: {
+          id: { in: isMany ? relation.value : [relation.value] },
+        },
+        depth: depth - 1,
+      });
+      if (isMany) {
+        relation.value = items as any; // !!!
+      } else {
+        relation.value = (items.length ? items[0] : undefined) as any; // !!!
+      }
     }
+    RELATION_CACHE.set(item.id, item);
   }
-
+  return item;
 }
+*/
 
-export function isObject(item: unknown): item is Record<string, unknown> {
-  return item !== null && (typeof item === 'object');
+export async function decorateRelation_<T extends ISchema = ISchema>(store: IStore, item: T, params: QueryParams = {}): Promise<T> {
+  const depth = params.depth != null ? params.depth : MOCK_SERVICE_DEFAULT_DEPTH;
+  if (depth === 0) {
+    return item;
+  }
+  const relations = collectRelations_(item);
+  for (const relation of relations) {
+    const isMany = Array.isArray(relation.value);
+    const items = await store[relation.relationTo].findMany({
+      ...params,
+      where: {
+        id: { in: isMany ? relation.value : [relation.value] },
+      },
+      depth: depth - 1,
+    });
+    if (isMany) {
+      relation.value = items as any; // !!!
+    } else {
+      relation.value = (items.length ? items[0] : undefined) as any; // !!!
+    }
+  }
+  return item;
 }
 
-export function isRelation(item: unknown): item is IPageRelation {
-  return isObject(item) && typeof item.relationTo === 'string' && item.value !== undefined;
+export async function decorateRelations_<T extends ISchema = ISchema>(store: IStore, items: T[], params: QueryParams = {}): Promise<T[]> {
+  for (const item of items) {
+    await decorateRelation_<T>(store, item, params);
+  }
+  return items;
 }

package/src/remote/remote.service.ts

@@ -23,7 +23,7 @@ export class RemoteService<T extends IEntity = IEntity> implements IQuerable<T>
     // console.log('RemoteService', this.key, 'findOne', url);
     const item = await remoteApiGet<B>(url);
     if (item) {
-      return this.decorator_(item, params);
+      return await this.decorateOne_(item, params);
     }
     return;
   }
@@ -37,7 +37,7 @@ export class RemoteService<T extends IEntity = IEntity> implements IQuerable<T>
     // console.log('RemoteService', this.key, 'findMany', url);
     const response = await remoteApiGet(url) as any; // !!! todo pagination<B[]> | B[]
     const items: B[] = Array.isArray(response.docs) ? response.docs : response;
-    return items.map(x => this.decorator_(x, params));
+    return await this.decorateMany_(items, params);
   }
 
   async findPaged<B extends T = T>(params: QueryParams = {}): Promise<{ docs: B[]; } & Pagination> {
@@ -49,30 +49,33 @@ export class RemoteService<T extends IEntity = IEntity> implements IQuerable<T>
     // console.log('RemoteService', this.key, 'findPaged', url);
     const response = await remoteApiGet<{ docs: B[]; } & Pagination>(url);
     let items: B[] = response.docs;
-    items = items.map(x => this.decorator_(x, params));
+    items = await this.decorateMany_(items, params);
     return { ...response, docs: items };
   }
 
+  // !!! todo params
   async create<B extends T = T>(payload: Omit<B, 'id'>): Promise<B> {
     const url = `/${this.key}`;
     // console.log('RemoteService', this.key, 'create', url);
     const item = await remoteApiPost<B>(url, payload);
-    return this.decorator_(item);
+    return await this.decorateOne_(item, {});
   }
 
+  // !!! todo params
   async update<B extends T = T>(payload: Partial<B>): Promise<B> {
     const url = `/${this.key}`;
     // console.log('RemoteService', this.key, 'update', url);
     const item = await remoteApiPut<B>(url, payload);
-    return this.decorator_(item);
+    return await this.decorateOne_(item, {});
   }
 
+  // !!! todo params
   async delete<B extends T = T>(id: IEquatable): Promise<B | undefined> {
     const params = {
       where: {
         id: {
           equals: id,
-        }
+        },
       },
     };
     const query = qsSerialize(params);
@@ -80,12 +83,14 @@ export class RemoteService<T extends IEntity = IEntity> implements IQuerable<T>
     const url = `/${this.key}${search}`;
     // console.log('RemoteService', this.key, 'delete', url);
     const item = await remoteApiDelete<B>(url);
-    return this.decorator_(item);
+    return await this.decorateOne_(item, {});
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  protected decorator_<B extends T = T>(item: B, params: QueryParams = {}): B {
+  protected async decorateOne_<B extends T = T>(item: B, params: QueryParams = {}): Promise<B> {
     return item;
   }
 
+  protected async decorateMany_<B extends T = T>(items: B[], params: QueryParams = {}): Promise<B[]> {
+    return items;
+  }
 }