@node-c/core 1.0.0-alpha9 → 1.0.0-beta1

package/src/domain/entityService/domain.entity.service.definitions.ts

@@ -0,0 +1,142 @@
+import { GenericObject } from '../../common/definitions';
+
+import {
+  DataBulkCreatePrivateOptions,
+  DataCreatePrivateOptions,
+  DataDeleteOptions,
+  DataDeletePrivateOptions,
+  DataDeleteResult,
+  DataFindOneOptions,
+  DataFindOnePrivateOptions,
+  DataFindOptions,
+  DataFindPrivateOptions,
+  DataFindResults,
+  DataUpdateOptions,
+  DataUpdatePrivateOptions,
+  DataUpdateResult
+} from '../../data/entityService';
+
+export interface DomainBaseAdditionalServiceOptionsOverrides {
+  filterByFirstServiceResultFields?: GenericObject<string>;
+  returnData?: boolean;
+  runOnNoFirstServiceResultOnly?: boolean | string;
+}
+
+export type DomainBaseOptions<Options> = Options & DomainBaseOptionsForAdditionalServices<Options>;
+
+export interface DomainBaseOptionsForAdditionalServices<Options> {
+  optionsOverridesByService?: GenericObject<Partial<Options> & DomainBaseAdditionalServiceOptionsOverrides>;
+  dataServices?: DomainDataServicesKey[];
+}
+
+export type DomainBaseOptionsForAdditionalServicesFull<
+  Options extends object | undefined = undefined,
+  SaveAdditionalResultsOptions extends object | undefined = undefined
+> = DomainBaseOptionsForAdditionalServices<Options> & DomainBaseOptionsWithSearchData<SaveAdditionalResultsOptions>;
+
+export interface DomainBaseOptionsWithSearchData<SaveAdditionalResultsOptions extends object | undefined = undefined> {
+  saveAdditionalResultsInFirstService?: {
+    saveOptions?: SaveAdditionalResultsOptions;
+    serviceName: string;
+    useResultsForFirstService?: boolean;
+  };
+}
+
+export interface DomainBaseResult<Result> {
+  result: Result;
+  resultsByService?: GenericObject<Result>;
+}
+
+export type DomainBulkCreatePrivateOptions = DataBulkCreatePrivateOptions;
+
+export type DomainBulkCreateData<Entity> = Partial<Entity>[];
+
+export type DomainBulkCreateOptions<Options = object> = DomainBaseOptions<Options>;
+
+export type DomainBulkCreateResult<Entity> = DomainBaseResult<Entity[]>;
+
+export type DomainCreateData<Entity> = Partial<Entity>;
+
+export type DomainCreateOptions<Options = object> = DomainBaseOptions<Options>;
+
+export type DomainCreatePrivateOptions = DataCreatePrivateOptions;
+
+export type DomainCreateResult<Entity> = DomainBaseResult<Entity>;
+
+export type DomainDeleteOptions<Options = object> = Options & DomainBaseOptions<DataDeleteOptions>;
+
+export type DomainDeletePrivateOptions = DataDeletePrivateOptions;
+
+export type DomainDeleteResult<Entity> = DomainBaseResult<DataDeleteResult<Entity>>;
+
+export interface DomainEntityServiceDefaultData<Entity> {
+  BulkCreate: DomainBulkCreateData<Entity>;
+  Create: DomainCreateData<Entity>;
+  Update: DomainUpdateData<Entity>;
+}
+
+export type DomainFindOneOptions<Options = object> = Options &
+  DomainBaseOptions<DataFindOneOptions> &
+  DomainBaseOptionsWithSearchData<DomainCreateOptions>;
+
+export type DomainFindOnePrivateOptions = DataFindOnePrivateOptions;
+
+export type DomainFindOneResult<Entity> = DomainBaseResult<Entity | null>;
+
+export type DomainFindOptions<Options = object> = Options &
+  DomainBaseOptions<DataFindOptions> &
+  DomainBaseOptionsWithSearchData<DomainBulkCreateOptions>;
+
+export type DomainFindPrivateOptions = DataFindPrivateOptions;
+
+export type DomainFindResult<Entity> = DomainBaseResult<DataFindResults<Entity>>;
+
+export enum DomainMethod {
+  // eslint-disable-next-line no-unused-vars
+  BulkCreate = 'bulkCreate',
+  // eslint-disable-next-line no-unused-vars
+  Create = 'create',
+  // eslint-disable-next-line no-unused-vars
+  Delete = 'delete',
+  // eslint-disable-next-line no-unused-vars
+  Find = 'find',
+  // eslint-disable-next-line no-unused-vars
+  FindOne = 'findOne',
+  // eslint-disable-next-line no-unused-vars
+  Update = 'update'
+}
+
+export const DOMAIN_ENTITY_SERVICE_DEFAULT_METHODS = [
+  DomainMethod.BulkCreate,
+  DomainMethod.Create,
+  DomainMethod.Delete,
+  DomainMethod.Find,
+  DomainMethod.FindOne,
+  DomainMethod.Update
+];
+
+export enum DomainDataEntityServiceType {
+  // eslint-disable-next-line no-unused-vars
+  All = 'all',
+  // eslint-disable-next-line no-unused-vars
+  Main = 'main'
+}
+
+export type DomainDataServicesKey = DomainDataEntityServiceType | string;
+
+export type DomainRunMethodInAdditionalServicesOptions<Options> = {
+  firstServiceResult?: unknown;
+  hasFirstServiceResult: boolean;
+  methodArgs?: unknown[];
+  methodName: string;
+  optionsArgIndex?: number;
+  optionsOverridesByService?: GenericObject<Partial<Options> & DomainBaseAdditionalServiceOptionsOverrides>;
+};
+
+export type DomainUpdateData<Entity> = Partial<Entity>;
+
+export type DomainUpdateOptions<Options = object> = Options & DomainBaseOptions<DataUpdateOptions>;
+
+export type DomainUpdatePrivateOptions = DataUpdatePrivateOptions;
+
+export type DomainUpdateResult<Entity> = DomainBaseResult<DataUpdateResult<Entity>>;

package/src/domain/entityService/domain.entity.service.spec.ts

@@ -0,0 +1,126 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { DomainEntityService } from './domain.entity.service';
+
+import {
+  DataDeleteOptions,
+  DataDeleteResult,
+  DataEntityService,
+  DataFindOneOptions,
+  DataFindOptions,
+  DataFindResults,
+  DataUpdateOptions,
+  DataUpdateResult
+} from '../../data/entityService';
+
+interface TestEntity {
+  id: number;
+  name: string;
+}
+
+describe('DomainEntityService', () => {
+  let mockDataService: DataEntityService<TestEntity>;
+  let domainService: DomainEntityService<TestEntity, DataEntityService<TestEntity>>;
+
+  beforeEach(() => {
+    // Create a fully typed mock for the underlying persistence service.
+    mockDataService = {
+      bulkCreate: vi.fn().mockResolvedValue([{ id: 1, name: 'Test1' }]),
+      create: vi.fn().mockResolvedValue({ id: 2, name: 'Test2' }),
+      count: vi.fn().mockResolvedValue({ count: 0 }),
+      delete: vi.fn().mockResolvedValue({ affected: 1 } as DataDeleteResult),
+      find: vi.fn().mockResolvedValue({ items: [{ id: 3, name: 'Test3' }] } as DataFindResults<TestEntity>),
+      findOne: vi.fn().mockResolvedValue({ id: 4, name: 'Test4' }),
+      getEntityName: vi.fn().mockResolvedValue('mockEntity'),
+      update: vi.fn().mockResolvedValue({ updated: { id: 5, name: 'Test5' } } as DataUpdateResult<TestEntity>)
+    };
+    domainService = new DomainEntityService<TestEntity, DataEntityService<TestEntity>>(mockDataService);
+  });
+
+  describe('bulkCreate', () => {
+    it('should call dataEntityService.bulkCreate with the provided data and return its result', async () => {
+      const data: TestEntity[] = [{ id: 10, name: 'BulkTest' }];
+      const result = await domainService.bulkCreate(data);
+      expect(mockDataService.bulkCreate).toHaveBeenCalledWith(data);
+      expect(result).toEqual({ result: [{ id: 1, name: 'Test1' }] });
+    });
+    it('should propagate errors from bulkCreate', async () => {
+      const error = new Error('bulk error');
+      (mockDataService.bulkCreate as ReturnType<typeof vi.fn>).mockRejectedValueOnce(error);
+      await expect(domainService.bulkCreate([{ id: 0, name: 'Error' }])).rejects.toThrow('bulk error');
+    });
+  });
+
+  describe('create', () => {
+    it('should call dataEntityService.create with the provided data and return its result', async () => {
+      const data: TestEntity = { id: 20, name: 'CreateTest' };
+      const result = await domainService.create(data);
+      expect(mockDataService.create).toHaveBeenCalledWith(data);
+      expect(result).toEqual({ result: { id: 2, name: 'Test2' } });
+    });
+    it('should propagate errors from create', async () => {
+      const error = new Error('create error');
+      (mockDataService.create as ReturnType<typeof vi.fn>).mockRejectedValueOnce(error);
+      await expect(domainService.create({ id: 0, name: 'Error' })).rejects.toThrow('create error');
+    });
+  });
+
+  describe('delete', () => {
+    it('should call dataEntityService.delete with correct options and return its result', async () => {
+      const options: DataDeleteOptions = { filters: { id: 1 } };
+      const result = await domainService.delete(options);
+      expect(mockDataService.delete).toHaveBeenCalledWith(options);
+      expect(result).toEqual({ result: { affected: 1 } });
+    });
+    it('should propagate errors from delete', async () => {
+      const error = new Error('delete error');
+      (mockDataService.delete as ReturnType<typeof vi.fn>).mockRejectedValueOnce(error);
+      await expect(domainService.delete({ filters: { id: 999 } })).rejects.toThrow('delete error');
+    });
+  });
+
+  describe('find', () => {
+    it('should call dataEntityService.find with correct options and return its result', async () => {
+      const options: DataFindOptions = { filters: { name: 'Test' } };
+      const result = await domainService.find(options);
+      expect(mockDataService.find).toHaveBeenCalledWith(options);
+      expect(result).toEqual({ result: { items: [{ id: 3, name: 'Test3' }] } });
+    });
+    it('should propagate errors from find', async () => {
+      const error = new Error('find error');
+      (mockDataService.find as ReturnType<typeof vi.fn>).mockRejectedValueOnce(error);
+      await expect(domainService.find({ filters: { name: 'Error' } })).rejects.toThrow('find error');
+    });
+  });
+
+  describe('findOne', () => {
+    it('should call dataEntityService.findOne with correct options and return its result', async () => {
+      const options: DataFindOneOptions = { filters: { id: 4 } };
+      const result = await domainService.findOne(options);
+      expect(mockDataService.findOne).toHaveBeenCalledWith(options);
+      expect(result).toEqual({ result: { id: 4, name: 'Test4' } });
+    });
+    it('should propagate errors from findOne', async () => {
+      const error = new Error('findOne error');
+      (mockDataService.findOne as ReturnType<typeof vi.fn>).mockRejectedValueOnce(error);
+      await expect(domainService.findOne({ filters: { id: 999 } })).rejects.toThrow('findOne error');
+    });
+  });
+
+  describe('update', () => {
+    it('should call dataEntityService.update with correct data and options and return its result', async () => {
+      const data: TestEntity = { id: 30, name: 'UpdateTest' };
+      const options: DataUpdateOptions = { filters: { id: 30 } };
+      const result = await domainService.update(data, options);
+      expect(mockDataService.update).toHaveBeenCalledWith(data, options);
+      expect(result).toEqual({ result: { updated: { id: 5, name: 'Test5' } } });
+    });
+    it('should propagate errors from update', async () => {
+      const error = new Error('update error');
+      (mockDataService.update as ReturnType<typeof vi.fn>).mockRejectedValueOnce(error);
+      await expect(domainService.update({ id: 0, name: 'Error' }, { filters: { id: 0 } })).rejects.toThrow(
+        'update error'
+      );
+    });
+  });
+});

package/src/domain/entityService/domain.entity.service.ts

@@ -0,0 +1,424 @@
+import ld from 'lodash';
+
+import {
+  DOMAIN_ENTITY_SERVICE_DEFAULT_METHODS,
+  DomainBaseAdditionalServiceOptionsOverrides,
+  DomainBulkCreateOptions,
+  DomainBulkCreatePrivateOptions,
+  DomainBulkCreateResult,
+  DomainCreateOptions,
+  DomainCreatePrivateOptions,
+  DomainCreateResult,
+  DomainDataEntityServiceType,
+  DomainDeleteOptions,
+  DomainDeletePrivateOptions,
+  DomainDeleteResult,
+  DomainEntityServiceDefaultData,
+  DomainFindOneOptions,
+  DomainFindOnePrivateOptions,
+  DomainFindOneResult,
+  DomainFindOptions,
+  DomainFindPrivateOptions,
+  DomainFindResult,
+  DomainMethod,
+  DomainRunMethodInAdditionalServicesOptions,
+  DomainUpdateOptions,
+  DomainUpdatePrivateOptions,
+  DomainUpdateResult
+} from './domain.entity.service.definitions';
+
+import { ApplicationError, GenericObject } from '../../common/definitions';
+
+import { LoggerService } from '../../common/logger';
+import { DataDefaultData, DataEntityService, DataFindResults } from '../../data/entityService';
+
+// TODO: privateOptionsOverrides by service
+export class DomainEntityService<
+  Entity,
+  EntityService extends DataEntityService<Entity, DataEntityServiceData>,
+  Data extends DomainEntityServiceDefaultData<Entity> = DomainEntityServiceDefaultData<Entity>,
+  AdditionalEntityServices extends
+    | Record<string, DataEntityService<Partial<Entity>, DataDefaultData<object>>>
+    | undefined = undefined,
+  DataEntityServiceData extends DataDefaultData<Entity> = DataDefaultData<Entity>
+> {
+  constructor(
+    // eslint-disable-next-line no-unused-vars
+    protected dataEntityService: EntityService,
+    // eslint-disable-next-line no-unused-vars
+    protected defaultMethods: string[] = DOMAIN_ENTITY_SERVICE_DEFAULT_METHODS,
+    // eslint-disable-next-line no-unused-vars
+    protected logger: LoggerService,
+    // eslint-disable-next-line no-unused-vars
+    protected additionalDataEntityServices?: AdditionalEntityServices,
+    // eslint-disable-next-line no-unused-vars
+    protected defaultAdditionalDataEntityServicesOptions?: {
+      [methodName: string]: {
+        [serviceName: string]: {
+          allowIncoming?: boolean;
+          serviceOptions?: DomainBaseAdditionalServiceOptionsOverrides & GenericObject<unknown>;
+        };
+      };
+    }
+  ) {}
+
+  public bulkCreate(
+    // eslint-disable-next-line no-unused-vars
+    data: Data['BulkCreate'],
+    // eslint-disable-next-line no-unused-vars
+    options?: DomainBulkCreateOptions,
+    // eslint-disable-next-line no-unused-vars
+    privateOptions?: DomainBulkCreatePrivateOptions
+  ): Promise<DomainBulkCreateResult<Entity>>;
+  async bulkCreate(
+    data: Data['BulkCreate'],
+    options?: DomainBulkCreateOptions,
+    privateOptions?: DomainBulkCreatePrivateOptions
+  ): Promise<DomainBulkCreateResult<Entity>> {
+    if (!this.defaultMethods?.includes(DomainMethod.BulkCreate)) {
+      throw new ApplicationError(`Method bulkCreate not implemented for class ${typeof this}.`);
+    }
+    // const defaultAdditionalDataEntityServicesOptions =
+    //   this.defaultAdditionalDataEntityServicesOptions?.bulkCreate;
+    const { optionsOverridesByService, dataServices = [DomainDataEntityServiceType.Main] } = options || {};
+    const [firstServiceName, ...otherServiceNames] = dataServices;
+    const result = await this.getDataService(firstServiceName).bulkCreate(data, privateOptions);
+    let actualOtherServiceNames: string[] = [];
+    let actualOptionsOverridesByService: typeof optionsOverridesByService = {};
+    // if (defaultAdditionalDataEntityServicesOptions) {
+    //   for (const serviceName in defaultAdditionalDataEntityServicesOptions) {
+    //     const { allowIncoming = true, serviceOptions } = defaultAdditionalDataEntityServicesOptions[serviceName];
+    //   }
+    // } else {
+    actualOtherServiceNames = otherServiceNames || [];
+    actualOptionsOverridesByService = optionsOverridesByService;
+    // }
+    return {
+      result,
+      resultsByService: await this.runMethodInAdditionalServices(actualOtherServiceNames, {
+        firstServiceResult: result,
+        hasFirstServiceResult: result.length > 0,
+        methodArgs: [result, privateOptions],
+        methodName: 'bulkCreate',
+        optionsArgIndex: 1,
+        optionsOverridesByService: actualOptionsOverridesByService
+      })
+    };
+  }
+
+  public create(
+    // eslint-disable-next-line no-unused-vars
+    data: Data['Create'],
+    // eslint-disable-next-line no-unused-vars
+    options?: DomainCreateOptions,
+    // eslint-disable-next-line no-unused-vars
+    privateOptions?: DomainCreatePrivateOptions
+  ): Promise<DomainCreateResult<Entity>>;
+  async create<Options extends object | undefined = undefined>(
+    data: Data['Create'],
+    options?: DomainCreateOptions<Options>,
+    privateOptions?: DomainCreatePrivateOptions
+  ): Promise<DomainCreateResult<Entity>> {
+    if (!this.defaultMethods?.includes(DomainMethod.Create)) {
+      throw new ApplicationError(`Method create not implemented for class ${typeof this}.`);
+    }
+    const { optionsOverridesByService, dataServices = [DomainDataEntityServiceType.Main] } = options || {};
+    const [firstServiceName, ...otherServiceNames] = dataServices;
+    const result = await this.getDataService(firstServiceName).create(data, privateOptions);
+    return {
+      result,
+      resultsByService: await this.runMethodInAdditionalServices(otherServiceNames || [], {
+        firstServiceResult: result,
+        hasFirstServiceResult: typeof result !== 'undefined' && result !== null,
+        methodArgs: [result, privateOptions],
+        methodName: 'create',
+        optionsArgIndex: 1,
+        optionsOverridesByService
+      })
+    };
+  }
+
+  public delete(
+    // eslint-disable-next-line no-unused-vars
+    options: DomainDeleteOptions,
+    // eslint-disable-next-line no-unused-vars
+    privateOptions?: DomainDeletePrivateOptions
+  ): Promise<DomainDeleteResult<Entity>>;
+  async delete(
+    options: DomainDeleteOptions,
+    privateOptions?: DomainDeletePrivateOptions
+  ): Promise<DomainDeleteResult<Entity>> {
+    if (!this.defaultMethods?.includes(DomainMethod.Delete)) {
+      throw new ApplicationError(`Method delete not implemented for class ${typeof this}.`);
+    }
+    const {
+      optionsOverridesByService,
+      dataServices = [DomainDataEntityServiceType.Main],
+      ...otherOptions
+    } = options || {};
+    const [firstServiceName, ...otherServiceNames] = dataServices;
+    const result = await this.getDataService(firstServiceName).delete(otherOptions, privateOptions);
+    return {
+      result,
+      resultsByService: await this.runMethodInAdditionalServices(otherServiceNames || [], {
+        firstServiceResult: { ...result, items: result.originalItems || [] },
+        hasFirstServiceResult: !!result.count,
+        methodArgs: [otherOptions, privateOptions],
+        methodName: 'delete',
+        optionsArgIndex: 0,
+        optionsOverridesByService
+      })
+    };
+  }
+
+  public find(
+    // eslint-disable-next-line no-unused-vars
+    options: DomainFindOptions,
+    // eslint-disable-next-line no-unused-vars
+    privateOptions?: DomainFindOnePrivateOptions
+  ): Promise<DomainFindResult<Entity>>;
+  async find(
+    options: DomainFindOptions,
+    privateOptions?: DomainFindOnePrivateOptions
+  ): Promise<DomainFindResult<Entity>> {
+    if (!this.defaultMethods?.includes(DomainMethod.Find)) {
+      throw new ApplicationError(`Method find not implemented for class ${typeof this}.`);
+    }
+    const {
+      optionsOverridesByService,
+      dataServices = [DomainDataEntityServiceType.Main],
+      saveAdditionalResultsInFirstService,
+      ...otherOptions
+    } = options || {};
+    const [firstServiceName, ...otherServiceNames] = dataServices;
+    let result = await this.getDataService(firstServiceName).find(otherOptions, privateOptions);
+    const hasFirstServiceResult = result.items.length > 0;
+    const resultsByService = await this.runMethodInAdditionalServices<DataFindResults<Entity>>(
+      otherServiceNames || [],
+      {
+        firstServiceResult: result,
+        hasFirstServiceResult,
+        methodArgs: [otherOptions, privateOptions],
+        methodName: 'find',
+        optionsArgIndex: 0,
+        optionsOverridesByService
+      }
+    );
+    if (saveAdditionalResultsInFirstService && resultsByService) {
+      const { saveOptions, serviceName, useResultsForFirstService } = saveAdditionalResultsInFirstService;
+      const dataFromAdditionalService = resultsByService[serviceName];
+      if (dataFromAdditionalService?.items?.length) {
+        await this.dataEntityService.bulkCreate(dataFromAdditionalService.items, saveOptions);
+        if (useResultsForFirstService && !hasFirstServiceResult) {
+          result = dataFromAdditionalService;
+        }
+      }
+    }
+    return {
+      result,
+      resultsByService
+    };
+  }
+
+  public findOne(
+    // eslint-disable-next-line no-unused-vars
+    options: DomainFindOneOptions,
+    // eslint-disable-next-line no-unused-vars
+    privateOptions?: DomainFindPrivateOptions
+  ): Promise<DomainFindOneResult<Entity>>;
+  async findOne(
+    options: DomainFindOneOptions,
+    privateOptions?: DomainFindPrivateOptions
+  ): Promise<DomainFindOneResult<Entity>> {
+    if (!this.defaultMethods?.includes(DomainMethod.FindOne)) {
+      throw new ApplicationError(`Method findOne not implemented for class ${typeof this}.`);
+    }
+    const {
+      optionsOverridesByService,
+      dataServices = [DomainDataEntityServiceType.Main],
+      saveAdditionalResultsInFirstService,
+      ...otherOptions
+    } = options || {};
+    const [firstServiceName, ...otherServiceNames] = dataServices;
+    let result: Entity | null = await this.getDataService(firstServiceName).findOne(otherOptions, privateOptions);
+    const hasFirstServiceResult = typeof result !== 'undefined' && result !== null;
+    const resultsByService = await this.runMethodInAdditionalServices<Entity | null>(otherServiceNames || [], {
+      firstServiceResult: result,
+      hasFirstServiceResult,
+      methodArgs: [otherOptions, privateOptions],
+      methodName: 'findOne',
+      optionsArgIndex: 0,
+      optionsOverridesByService
+    });
+    if (saveAdditionalResultsInFirstService && resultsByService) {
+      const { saveOptions, serviceName, useResultsForFirstService } = saveAdditionalResultsInFirstService;
+      const dataFromAdditionalService = resultsByService[serviceName];
+      if (dataFromAdditionalService) {
+        await this.dataEntityService.create(dataFromAdditionalService, saveOptions);
+        if (useResultsForFirstService && !hasFirstServiceResult) {
+          result = dataFromAdditionalService;
+        }
+      }
+    }
+    return {
+      result,
+      resultsByService
+    };
+  }
+
+  protected getDataService(serviceName: DomainDataEntityServiceType.Main | string): DataEntityService<Entity> {
+    if (serviceName === DomainDataEntityServiceType.Main) {
+      return this.dataEntityService;
+    }
+    const service = this.additionalDataEntityServices?.[serviceName];
+    if (!service) {
+      throw new ApplicationError(
+        `DataEntityService ${serviceName} does not exist for DomainEntityService ${this.dataEntityService.getEntityName(true) || '(no entity name)'}.`
+      );
+    }
+    return service as DataEntityService<Entity>;
+  }
+
+  protected async runMethodInAdditionalServices<ServiceReturnData>(
+    serviceNames: string[],
+    options: DomainRunMethodInAdditionalServicesOptions<unknown>
+  ): Promise<GenericObject<ServiceReturnData> | undefined> {
+    if (!serviceNames.length) {
+      return undefined;
+    }
+    const {
+      firstServiceResult,
+      hasFirstServiceResult,
+      methodArgs = [],
+      methodName,
+      optionsArgIndex,
+      optionsOverridesByService = {}
+    } = options;
+    const returnDataByService: GenericObject<ServiceReturnData> = {};
+    if (!this.additionalDataEntityServices) {
+      throw new ApplicationError(
+        `No additional DataEntityServices exist for DomainEntityService ${this.dataEntityService.getEntityName(true) || '(no entity name)'}.`
+      );
+    }
+    if (
+      Object.keys(optionsOverridesByService).length &&
+      (typeof optionsArgIndex === 'undefined' || optionsArgIndex < 0 || optionsArgIndex > methodArgs.length - 1)
+    ) {
+      throw new ApplicationError(
+        `Invalid optionsArgIndex value ${optionsArgIndex} provided for DomainEntityService ${this.dataEntityService.getEntityName(true) || '(no entity name)'}.}.`
+      );
+    }
+    for (const i in serviceNames) {
+      const serviceName = serviceNames[i];
+      const service = this.getDataService(serviceName);
+      if (!service) {
+        throw new ApplicationError(
+          `DataEntityService ${serviceName} does not exist for DomainEntityService ${this.dataEntityService.getEntityName(true) || '(no entity name)'}.`
+        );
+      }
+      const serviceMethodOptionsOverrides = optionsOverridesByService[serviceName] || {};
+      const {
+        filterByFirstServiceResultFields,
+        runOnNoFirstServiceResultOnly = true,
+        ...actualMethodOptionsOverrides
+      } = serviceMethodOptionsOverrides;
+      // be extra careful when working with data that has TTL as the main service,
+      // since there is no way to check for limited results here.
+      if (
+        (runOnNoFirstServiceResultOnly === true || runOnNoFirstServiceResultOnly === 'true') &&
+        hasFirstServiceResult
+      ) {
+        continue;
+      }
+      const serviceMethodArgs = ld.cloneDeep(methodArgs);
+      if (typeof serviceMethodArgs[optionsArgIndex!] === 'undefined') {
+        if (optionsArgIndex! > serviceMethodArgs.length - 1) {
+          serviceMethodArgs.push(actualMethodOptionsOverrides);
+        } else {
+          serviceMethodArgs[optionsArgIndex!] = actualMethodOptionsOverrides;
+        }
+      } else {
+        serviceMethodArgs[optionsArgIndex!] = {
+          ...(serviceMethodArgs[optionsArgIndex!] as object),
+          ...actualMethodOptionsOverrides
+        };
+      }
+      if (filterByFirstServiceResultFields && Object.keys(filterByFirstServiceResultFields).length) {
+        if (!hasFirstServiceResult) {
+          continue;
+        }
+        const filters: GenericObject = {};
+        const resultItems: GenericObject[] = (firstServiceResult as { items?: GenericObject[] }).items || [
+          firstServiceResult as GenericObject
+        ];
+        resultItems.forEach(resultItem => {
+          if (!resultItem) {
+            return;
+          }
+          for (const sourceFieldName in filterByFirstServiceResultFields) {
+            const fieldValue = resultItem[sourceFieldName];
+            const targetFieldName = filterByFirstServiceResultFields[sourceFieldName];
+            if (typeof fieldValue === 'undefined') {
+              return;
+            }
+            if (!filters[targetFieldName]) {
+              filters[targetFieldName] = [];
+            }
+            (filters[targetFieldName] as unknown[]).push(fieldValue);
+          }
+        });
+        if (Object.keys(filters).length) {
+          const serviceMethodOptions = serviceMethodArgs[optionsArgIndex!] as GenericObject & {
+            filters?: GenericObject;
+          };
+          serviceMethodArgs[optionsArgIndex!] = {
+            ...serviceMethodOptions,
+            filters: {
+              ...ld.omit(serviceMethodOptions.filters || {}, ['page', 'perPage']),
+              ...filters
+            },
+            findAll: true
+          };
+        }
+      }
+      returnDataByService[serviceName] = (await (
+        service[methodName as keyof DataEntityService<Entity>] as unknown as (
+          ..._args: unknown[]
+        ) => Promise<ServiceReturnData>
+      ).apply(service, serviceMethodArgs)) as ServiceReturnData;
+    }
+    return returnDataByService;
+  }
+
+  public update(
+    // eslint-disable-next-line no-unused-vars
+    data: Data['Update'],
+    // eslint-disable-next-line no-unused-vars
+    options: DomainUpdateOptions,
+    // eslint-disable-next-line no-unused-vars
+    privateOptions?: DomainUpdatePrivateOptions
+  ): Promise<DomainUpdateResult<Entity>>;
+  async update(
+    data: Data['Update'],
+    options: DomainUpdateOptions,
+    privateOptions?: DomainUpdatePrivateOptions
+  ): Promise<DomainUpdateResult<Entity>> {
+    if (!this.defaultMethods?.includes(DomainMethod.Update)) {
+      throw new ApplicationError(`Method update not implemented for class ${typeof this}.`);
+    }
+    const { optionsOverridesByService, dataServices = [DomainDataEntityServiceType.Main], ...otherOptions } = options;
+    const [firstServiceName, ...otherServiceNames] = dataServices;
+    const result = await this.getDataService(firstServiceName).update(data, otherOptions, privateOptions);
+    return {
+      result,
+      resultsByService: await this.runMethodInAdditionalServices(otherServiceNames || [], {
+        firstServiceResult: result,
+        hasFirstServiceResult: !!result.count,
+        methodArgs: [data, otherOptions, privateOptions],
+        methodName: 'update',
+        optionsArgIndex: 1,
+        optionsOverridesByService
+      })
+    };
+  }
+}

package/src/domain/entityService/index.ts

@@ -0,0 +1,2 @@
+export * from './domain.entity.service';
+export * from './domain.entity.service.definitions';