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

package/dist/{persistance/entityService/persistance.entity.service.js → data/entityService/data.entity.service.js}

@@ -9,22 +9,28 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PersistanceEntityService = void 0;
+exports.DataEntityService = void 0;
 const definitions_1 = require("../../common/definitions");
-class PersistanceEntityService {
+class DataEntityService {
+    constructor(configProvider, dataModuleName) {
+        this.configProvider = configProvider;
+        this.dataModuleName = dataModuleName;
+        const { settingsPerEntity } = configProvider.config.data[dataModuleName];
+        this.settings = settingsPerEntity || {};
+    }
     bulkCreate(_data, _options, _privateOptions) {
         return __awaiter(this, void 0, void 0, function* () {
             throw new definitions_1.ApplicationError(`Method bulkCreate not implemented for class ${typeof this}.`);
         });
     }
-    create(_data, _options, _privateOptions) {
+    count(_options, _privateOptions) {
         return __awaiter(this, void 0, void 0, function* () {
-            throw new definitions_1.ApplicationError(`Method create not implemented for class ${typeof this}.`);
+            throw new definitions_1.ApplicationError(`Method count not implemented for class ${typeof this}.`);
         });
     }
-    count(_options, _privateOptions) {
+    create(_data, _options, _privateOptions) {
         return __awaiter(this, void 0, void 0, function* () {
-            throw new definitions_1.ApplicationError(`Method count not implemented for class ${typeof this}.`);
+            throw new definitions_1.ApplicationError(`Method create not implemented for class ${typeof this}.`);
         });
     }
     delete(_options, _privateOptions) {
@@ -36,14 +42,40 @@ class PersistanceEntityService {
     findOne(_options, _privateOptions) {
         throw new definitions_1.ApplicationError(`Method findOne not implemented for class ${typeof this}.`);
     }
-    getEntityName() {
+    getEntityName(noError) {
+        if (noError) {
+            return null;
+        }
         throw new definitions_1.ApplicationError(`Method getEntityName not implemented for class ${typeof this}.`);
     }
+    processObjectAllowedFields(data, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { settings } = this;
+            const { allowedFields, isEnabled, objectType } = options;
+            if (isEnabled === false || (typeof isEnabled === 'undefined' && !settings[objectType])) {
+                return data;
+            }
+            const actualData = data instanceof Array ? data : [data];
+            const processedData = [];
+            actualData.forEach(dataItem => {
+                const processedDataItem = {};
+                allowedFields.forEach(fieldName => {
+                    const typedFieldName = fieldName;
+                    const value = dataItem[typedFieldName];
+                    if (typeof value !== 'undefined') {
+                        processedDataItem[typedFieldName] = value;
+                    }
+                });
+                processedData.push(processedDataItem);
+            });
+            return processedData.length === 1 ? processedData[0] : processedData;
+        });
+    }
     update(_data, _options, _privateOptions) {
         return __awaiter(this, void 0, void 0, function* () {
             throw new definitions_1.ApplicationError(`Method update not implemented for class ${typeof this}.`);
         });
     }
 }
-exports.PersistanceEntityService = PersistanceEntityService;
-//# sourceMappingURL=persistance.entity.service.js.map
+exports.DataEntityService = DataEntityService;
+//# sourceMappingURL=data.entity.service.js.map

package/dist/data/entityService/data.entity.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data.entity.service.js","sourceRoot":"","sources":["../../../src/data/entityService/data.entity.service.ts"],"names":[],"mappings":"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"}

package/dist/data/entityService/index.d.ts

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

package/dist/data/entityService/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./data.entity.service"), exports);
+__exportStar(require("./data.entity.service.definitions"), exports);
+//# sourceMappingURL=index.js.map

package/dist/data/entityService/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/data/entityService/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,wDAAsC;AACtC,oEAAkD"}

package/dist/domain/entityService/domain.entity.service.d.ts

@@ -1,17 +1,32 @@
-import { DomainBulkCreateOptions, DomainBulkCreateResult, DomainCreateOptions, DomainCreateResult, DomainDeleteOptions, DomainDeleteResult, DomainEntityServiceDefaultData, DomainFindOneOptions, DomainFindOneResult, DomainFindOptions, DomainFindResult, DomainPersistanceEntityServiceType, DomainRunMethodInAdditionalServicesOptions, DomainUpdateOptions, DomainUpdateResult } from './domain.entity.service.definitions';
+import { DomainBaseAdditionalServiceOptionsOverrides, DomainBulkCreateOptions, DomainBulkCreatePrivateOptions, DomainBulkCreateResult, DomainCreateOptions, DomainCreatePrivateOptions, DomainCreateResult, DomainDataEntityServiceType, DomainDeleteOptions, DomainDeletePrivateOptions, DomainDeleteResult, DomainEntityServiceDefaultData, DomainFindOneOptions, DomainFindOnePrivateOptions, DomainFindOneResult, DomainFindOptions, DomainFindPrivateOptions, DomainFindResult, DomainRunMethodInAdditionalServicesOptions, DomainUpdateOptions, DomainUpdatePrivateOptions, DomainUpdateResult } from './domain.entity.service.definitions';
 import { GenericObject } from '../../common/definitions';
-import { PersistanceEntityService } from '../../persistance/entityService';
-export declare class DomainEntityService<Entity, EntityService extends PersistanceEntityService<Entity>, Data extends DomainEntityServiceDefaultData<Entity> = DomainEntityServiceDefaultData<Entity>, AdditionalEntityServices extends Record<string, PersistanceEntityService<Partial<Entity>>> | undefined = undefined> {
-    protected persistanceEntityService: EntityService;
+import { DataDefaultData, DataEntityService } from '../../data/entityService';
+export declare 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>> {
+    protected dataEntityService: EntityService;
     protected defaultMethods: string[];
-    protected additionalPersistanceEntityServices?: AdditionalEntityServices | undefined;
-    constructor(persistanceEntityService: EntityService, defaultMethods?: string[], additionalPersistanceEntityServices?: AdditionalEntityServices | undefined);
-    bulkCreate(data: Data['BulkCreate'], options?: DomainBulkCreateOptions, privateOptions?: unknown): Promise<DomainBulkCreateResult<Entity>>;
-    create(data: Data['Create'], options?: DomainCreateOptions, privateOptions?: unknown): Promise<DomainCreateResult<Entity>>;
-    delete(options: DomainDeleteOptions, privateOptions?: unknown): Promise<DomainDeleteResult<Entity>>;
-    find(options: DomainFindOptions, privateOptions?: unknown): Promise<DomainFindResult<Entity>>;
-    findOne(options: DomainFindOneOptions, privateOptions?: unknown): Promise<DomainFindOneResult<Entity>>;
-    protected getPersistanceService(serviceName: DomainPersistanceEntityServiceType.Main | string): PersistanceEntityService<Entity>;
+    protected additionalDataEntityServices?: AdditionalEntityServices | undefined;
+    protected defaultAdditionalDataEntityServicesOptions?: {
+        [methodName: string]: {
+            [serviceName: string]: {
+                allowIncoming?: boolean;
+                serviceOptions?: DomainBaseAdditionalServiceOptionsOverrides & GenericObject<unknown>;
+            };
+        };
+    } | undefined;
+    constructor(dataEntityService: EntityService, defaultMethods?: string[], additionalDataEntityServices?: AdditionalEntityServices | undefined, defaultAdditionalDataEntityServicesOptions?: {
+        [methodName: string]: {
+            [serviceName: string]: {
+                allowIncoming?: boolean;
+                serviceOptions?: DomainBaseAdditionalServiceOptionsOverrides & GenericObject<unknown>;
+            };
+        };
+    } | undefined);
+    bulkCreate(data: Data['BulkCreate'], options?: DomainBulkCreateOptions, privateOptions?: DomainBulkCreatePrivateOptions): Promise<DomainBulkCreateResult<Entity>>;
+    create(data: Data['Create'], options?: DomainCreateOptions, privateOptions?: DomainCreatePrivateOptions): Promise<DomainCreateResult<Entity>>;
+    delete(options: DomainDeleteOptions, privateOptions?: DomainDeletePrivateOptions): Promise<DomainDeleteResult<Entity>>;
+    find(options: DomainFindOptions, privateOptions?: DomainFindOnePrivateOptions): Promise<DomainFindResult<Entity>>;
+    findOne(options: DomainFindOneOptions, privateOptions?: DomainFindPrivateOptions): Promise<DomainFindOneResult<Entity>>;
+    protected getDataService(serviceName: DomainDataEntityServiceType.Main | string): DataEntityService<Entity>;
     protected runMethodInAdditionalServices<ServiceReturnData>(serviceNames: string[], options: DomainRunMethodInAdditionalServicesOptions<unknown>): Promise<GenericObject<ServiceReturnData> | undefined>;
-    update(data: Data['Update'], options: DomainUpdateOptions, privateOptions?: unknown): Promise<DomainUpdateResult<Entity>>;
+    update(data: Data['Update'], options: DomainUpdateOptions, privateOptions?: DomainUpdatePrivateOptions): Promise<DomainUpdateResult<Entity>>;
 }

package/dist/domain/entityService/domain.entity.service.definitions.d.ts

@@ -1,43 +1,49 @@
 import { GenericObject } from '../../common/definitions';
-import { PersistanceDeleteOptions, PersistanceDeleteResult, PersistanceFindOneOptions, PersistanceFindOptions, PersistanceFindResults, PersistanceUpdateOptions, PersistanceUpdateResult } from '../../persistance/entityService';
+import { DataBulkCreatePrivateOptions, DataCreatePrivateOptions, DataDeleteOptions, DataDeletePrivateOptions, DataDeleteResult, DataFindOneOptions, DataFindOnePrivateOptions, DataFindOptions, DataFindPrivateOptions, DataFindResults, DataUpdateOptions, DataUpdatePrivateOptions, DataUpdateResult } from '../../data/entityService';
 export interface DomainBaseAdditionalServiceOptionsOverrides {
-    filterByMainResultFields?: GenericObject<string>;
-    runOnNoMainServiceResultOnly?: boolean | string;
+    filterByFirstServiceResultFields?: GenericObject<string>;
+    returnData?: boolean;
+    runOnNoFirstServiceResultOnly?: boolean | string;
 }
 export type DomainBaseOptions<Options> = Options & DomainBaseOptionsForAdditionalServices<Options>;
 export interface DomainBaseOptionsForAdditionalServices<Options> {
     optionsOverridesByService?: GenericObject<Partial<Options> & DomainBaseAdditionalServiceOptionsOverrides>;
-    persistanceServices?: DomainPersistanceServicesKey[];
+    dataServices?: DomainDataServicesKey[];
 }
-export type DomainBaseOptionsForAdditionalServicesFull<Options extends object | undefined = undefined, SaveAdditionalResultsOptions extends object | undefined = undefined> = DomainBaseOptionsForAdditionalServices<Options> & DomainBaseOptionsWithSearchPersistance<SaveAdditionalResultsOptions>;
-export interface DomainBaseOptionsWithSearchPersistance<SaveAdditionalResultsOptions extends object | undefined = undefined> {
-    saveAdditionalResultsInMain?: {
+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;
-        useResultsAsMain?: boolean;
+        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<PersistanceDeleteOptions>;
-export type DomainDeleteResult<Entity> = DomainBaseResult<PersistanceDeleteResult<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<PersistanceFindOneOptions> & DomainBaseOptionsWithSearchPersistance<DomainCreateOptions>;
+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<PersistanceFindOptions> & DomainBaseOptionsWithSearchPersistance<DomainBulkCreateOptions>;
-export type DomainFindResult<Entity> = DomainBaseResult<PersistanceFindResults<Entity>>;
+export type DomainFindOptions<Options = object> = Options & DomainBaseOptions<DataFindOptions> & DomainBaseOptionsWithSearchData<DomainBulkCreateOptions>;
+export type DomainFindPrivateOptions = DataFindPrivateOptions;
+export type DomainFindResult<Entity> = DomainBaseResult<DataFindResults<Entity>>;
 export declare enum DomainMethod {
     BulkCreate = "bulkCreate",
     Create = "create",
@@ -47,19 +53,20 @@ export declare enum DomainMethod {
     Update = "update"
 }
 export declare const DOMAIN_ENTITY_SERVICE_DEFAULT_METHODS: DomainMethod[];
-export declare enum DomainPersistanceEntityServiceType {
+export declare enum DomainDataEntityServiceType {
     All = "all",
     Main = "main"
 }
-export type DomainPersistanceServicesKey = DomainPersistanceEntityServiceType | string;
+export type DomainDataServicesKey = DomainDataEntityServiceType | string;
 export type DomainRunMethodInAdditionalServicesOptions<Options> = {
-    hasMainServiceResult: boolean;
-    mainServiceResult?: unknown;
+    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<PersistanceUpdateOptions>;
-export type DomainUpdateResult<Entity> = DomainBaseResult<PersistanceUpdateResult<Entity>>;
+export type DomainUpdateOptions<Options = object> = Options & DomainBaseOptions<DataUpdateOptions>;
+export type DomainUpdatePrivateOptions = DataUpdatePrivateOptions;
+export type DomainUpdateResult<Entity> = DomainBaseResult<DataUpdateResult<Entity>>;

package/dist/domain/entityService/domain.entity.service.definitions.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DomainPersistanceEntityServiceType = exports.DOMAIN_ENTITY_SERVICE_DEFAULT_METHODS = exports.DomainMethod = void 0;
+exports.DomainDataEntityServiceType = exports.DOMAIN_ENTITY_SERVICE_DEFAULT_METHODS = exports.DomainMethod = void 0;
 var DomainMethod;
 (function (DomainMethod) {
     DomainMethod["BulkCreate"] = "bulkCreate";
@@ -18,9 +18,9 @@ exports.DOMAIN_ENTITY_SERVICE_DEFAULT_METHODS = [
     DomainMethod.FindOne,
     DomainMethod.Update
 ];
-var DomainPersistanceEntityServiceType;
-(function (DomainPersistanceEntityServiceType) {
-    DomainPersistanceEntityServiceType["All"] = "all";
-    DomainPersistanceEntityServiceType["Main"] = "main";
-})(DomainPersistanceEntityServiceType || (exports.DomainPersistanceEntityServiceType = DomainPersistanceEntityServiceType = {}));
+var DomainDataEntityServiceType;
+(function (DomainDataEntityServiceType) {
+    DomainDataEntityServiceType["All"] = "all";
+    DomainDataEntityServiceType["Main"] = "main";
+})(DomainDataEntityServiceType || (exports.DomainDataEntityServiceType = DomainDataEntityServiceType = {}));
 //# sourceMappingURL=domain.entity.service.definitions.js.map

package/dist/domain/entityService/domain.entity.service.definitions.js.map

@@ -1 +1 @@
-{"version":3,"file":"domain.entity.service.definitions.js","sourceRoot":"","sources":["../../../src/domain/entityService/domain.entity.service.definitions.ts"],"names":[],"mappings":";;;AA+EA,IAAY,YAaX;AAbD,WAAY,YAAY;IAEtB,yCAAyB,CAAA;IAEzB,iCAAiB,CAAA;IAEjB,iCAAiB,CAAA;IAEjB,6BAAa,CAAA;IAEb,mCAAmB,CAAA;IAEnB,iCAAiB,CAAA;AACnB,CAAC,EAbW,YAAY,4BAAZ,YAAY,QAavB;AAEY,QAAA,qCAAqC,GAAG;IACnD,YAAY,CAAC,UAAU;IACvB,YAAY,CAAC,MAAM;IACnB,YAAY,CAAC,MAAM;IACnB,YAAY,CAAC,IAAI;IACjB,YAAY,CAAC,OAAO;IACpB,YAAY,CAAC,MAAM;CACpB,CAAC;AAEF,IAAY,kCAKX;AALD,WAAY,kCAAkC;IAE5C,iDAAW,CAAA;IAEX,mDAAa,CAAA;AACf,CAAC,EALW,kCAAkC,kDAAlC,kCAAkC,QAK7C"}
+{"version":3,"file":"domain.entity.service.definitions.js","sourceRoot":"","sources":["../../../src/domain/entityService/domain.entity.service.definitions.ts"],"names":[],"mappings":";;;AA6FA,IAAY,YAaX;AAbD,WAAY,YAAY;IAEtB,yCAAyB,CAAA;IAEzB,iCAAiB,CAAA;IAEjB,iCAAiB,CAAA;IAEjB,6BAAa,CAAA;IAEb,mCAAmB,CAAA;IAEnB,iCAAiB,CAAA;AACnB,CAAC,EAbW,YAAY,4BAAZ,YAAY,QAavB;AAEY,QAAA,qCAAqC,GAAG;IACnD,YAAY,CAAC,UAAU;IACvB,YAAY,CAAC,MAAM;IACnB,YAAY,CAAC,MAAM;IACnB,YAAY,CAAC,IAAI;IACjB,YAAY,CAAC,OAAO;IACpB,YAAY,CAAC,MAAM;CACpB,CAAC;AAEF,IAAY,2BAKX;AALD,WAAY,2BAA2B;IAErC,0CAAW,CAAA;IAEX,4CAAa,CAAA;AACf,CAAC,EALW,2BAA2B,2CAA3B,2BAA2B,QAKtC"}

package/dist/domain/entityService/domain.entity.service.js

@@ -24,15 +24,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DomainEntityService = void 0;
-const immutable_1 = __importDefault(require("immutable"));
-const ramda_1 = require("ramda");
+const lodash_1 = __importDefault(require("lodash"));
 const domain_entity_service_definitions_1 = require("./domain.entity.service.definitions");
 const definitions_1 = require("../../common/definitions");
 class DomainEntityService {
-    constructor(persistanceEntityService, defaultMethods = domain_entity_service_definitions_1.DOMAIN_ENTITY_SERVICE_DEFAULT_METHODS, additionalPersistanceEntityServices) {
-        this.persistanceEntityService = persistanceEntityService;
+    constructor(dataEntityService, defaultMethods = domain_entity_service_definitions_1.DOMAIN_ENTITY_SERVICE_DEFAULT_METHODS, additionalDataEntityServices, defaultAdditionalDataEntityServicesOptions) {
+        this.dataEntityService = dataEntityService;
         this.defaultMethods = defaultMethods;
-        this.additionalPersistanceEntityServices = additionalPersistanceEntityServices;
+        this.additionalDataEntityServices = additionalDataEntityServices;
+        this.defaultAdditionalDataEntityServicesOptions = defaultAdditionalDataEntityServicesOptions;
     }
     bulkCreate(data, options, privateOptions) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -40,18 +40,22 @@ class DomainEntityService {
             if (!((_a = this.defaultMethods) === null || _a === void 0 ? void 0 : _a.includes(domain_entity_service_definitions_1.DomainMethod.BulkCreate))) {
                 throw new definitions_1.ApplicationError(`Method bulkCreate not implemented for class ${typeof this}.`);
             }
-            const { optionsOverridesByService, persistanceServices = [domain_entity_service_definitions_1.DomainPersistanceEntityServiceType.Main] } = options || {};
-            const [firstServiceName, ...otherServiceNames] = persistanceServices;
-            const result = yield this.getPersistanceService(firstServiceName).bulkCreate(data, privateOptions);
+            const { optionsOverridesByService, dataServices = [domain_entity_service_definitions_1.DomainDataEntityServiceType.Main] } = options || {};
+            const [firstServiceName, ...otherServiceNames] = dataServices;
+            const result = yield this.getDataService(firstServiceName).bulkCreate(data, privateOptions);
+            let actualOtherServiceNames = [];
+            let actualOptionsOverridesByService = {};
+            actualOtherServiceNames = otherServiceNames || [];
+            actualOptionsOverridesByService = optionsOverridesByService;
             return {
                 result,
-                resultsByService: yield this.runMethodInAdditionalServices(otherServiceNames || [], {
-                    hasMainServiceResult: result.length > 0,
-                    mainServiceResult: result,
+                resultsByService: yield this.runMethodInAdditionalServices(actualOtherServiceNames, {
+                    firstServiceResult: result,
+                    hasFirstServiceResult: result.length > 0,
                     methodArgs: [result, privateOptions],
                     methodName: 'bulkCreate',
                     optionsArgIndex: 1,
-                    optionsOverridesByService
+                    optionsOverridesByService: actualOptionsOverridesByService
                 })
             };
         });
@@ -62,14 +66,14 @@ class DomainEntityService {
             if (!((_a = this.defaultMethods) === null || _a === void 0 ? void 0 : _a.includes(domain_entity_service_definitions_1.DomainMethod.Create))) {
                 throw new definitions_1.ApplicationError(`Method create not implemented for class ${typeof this}.`);
             }
-            const { optionsOverridesByService, persistanceServices = [domain_entity_service_definitions_1.DomainPersistanceEntityServiceType.Main] } = options || {};
-            const [firstServiceName, ...otherServiceNames] = persistanceServices;
-            const result = yield this.getPersistanceService(firstServiceName).create(data, privateOptions);
+            const { optionsOverridesByService, dataServices = [domain_entity_service_definitions_1.DomainDataEntityServiceType.Main] } = options || {};
+            const [firstServiceName, ...otherServiceNames] = dataServices;
+            const result = yield this.getDataService(firstServiceName).create(data, privateOptions);
             return {
                 result,
                 resultsByService: yield this.runMethodInAdditionalServices(otherServiceNames || [], {
-                    hasMainServiceResult: typeof result !== 'undefined' && result !== null,
-                    mainServiceResult: result,
+                    firstServiceResult: result,
+                    hasFirstServiceResult: typeof result !== 'undefined' && result !== null,
                     methodArgs: [result, privateOptions],
                     methodName: 'create',
                     optionsArgIndex: 1,
@@ -84,14 +88,14 @@ class DomainEntityService {
             if (!((_a = this.defaultMethods) === null || _a === void 0 ? void 0 : _a.includes(domain_entity_service_definitions_1.DomainMethod.Delete))) {
                 throw new definitions_1.ApplicationError(`Method delete not implemented for class ${typeof this}.`);
             }
-            const _b = options || {}, { optionsOverridesByService, persistanceServices = [domain_entity_service_definitions_1.DomainPersistanceEntityServiceType.Main] } = _b, otherOptions = __rest(_b, ["optionsOverridesByService", "persistanceServices"]);
-            const [firstServiceName, ...otherServiceNames] = persistanceServices;
-            const result = yield this.getPersistanceService(firstServiceName).delete(otherOptions, privateOptions);
+            const _b = options || {}, { optionsOverridesByService, dataServices = [domain_entity_service_definitions_1.DomainDataEntityServiceType.Main] } = _b, otherOptions = __rest(_b, ["optionsOverridesByService", "dataServices"]);
+            const [firstServiceName, ...otherServiceNames] = dataServices;
+            const result = yield this.getDataService(firstServiceName).delete(otherOptions, privateOptions);
             return {
                 result,
                 resultsByService: yield this.runMethodInAdditionalServices(otherServiceNames || [], {
-                    hasMainServiceResult: !!result.count,
-                    mainServiceResult: result,
+                    firstServiceResult: Object.assign(Object.assign({}, result), { items: result.originalItems || [] }),
+                    hasFirstServiceResult: !!result.count,
                     methodArgs: [otherOptions, privateOptions],
                     methodName: 'delete',
                     optionsArgIndex: 0,
@@ -102,28 +106,28 @@ class DomainEntityService {
     }
     find(options, privateOptions) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            var _a, _b;
             if (!((_a = this.defaultMethods) === null || _a === void 0 ? void 0 : _a.includes(domain_entity_service_definitions_1.DomainMethod.Find))) {
                 throw new definitions_1.ApplicationError(`Method find not implemented for class ${typeof this}.`);
             }
-            const _b = options || {}, { optionsOverridesByService, persistanceServices = [domain_entity_service_definitions_1.DomainPersistanceEntityServiceType.Main], saveAdditionalResultsInMain } = _b, otherOptions = __rest(_b, ["optionsOverridesByService", "persistanceServices", "saveAdditionalResultsInMain"]);
-            const [firstServiceName, ...otherServiceNames] = persistanceServices;
-            let result = yield this.getPersistanceService(firstServiceName).find(otherOptions, privateOptions);
-            const hasMainServiceResult = result.items.length > 0;
+            const _c = options || {}, { optionsOverridesByService, dataServices = [domain_entity_service_definitions_1.DomainDataEntityServiceType.Main], saveAdditionalResultsInFirstService } = _c, otherOptions = __rest(_c, ["optionsOverridesByService", "dataServices", "saveAdditionalResultsInFirstService"]);
+            const [firstServiceName, ...otherServiceNames] = dataServices;
+            let result = yield this.getDataService(firstServiceName).find(otherOptions, privateOptions);
+            const hasFirstServiceResult = result.items.length > 0;
             const resultsByService = yield this.runMethodInAdditionalServices(otherServiceNames || [], {
-                hasMainServiceResult,
-                mainServiceResult: result,
+                firstServiceResult: result,
+                hasFirstServiceResult,
                 methodArgs: [otherOptions, privateOptions],
                 methodName: 'find',
                 optionsArgIndex: 0,
                 optionsOverridesByService
             });
-            if (saveAdditionalResultsInMain && resultsByService) {
-                const { saveOptions, serviceName, useResultsAsMain } = saveAdditionalResultsInMain;
+            if (saveAdditionalResultsInFirstService && resultsByService) {
+                const { saveOptions, serviceName, useResultsForFirstService } = saveAdditionalResultsInFirstService;
                 const dataFromAdditionalService = resultsByService[serviceName];
-                if (dataFromAdditionalService.items.length) {
-                    yield this.persistanceEntityService.bulkCreate(dataFromAdditionalService.items, saveOptions);
-                    if (useResultsAsMain && !hasMainServiceResult) {
+                if ((_b = dataFromAdditionalService === null || dataFromAdditionalService === void 0 ? void 0 : dataFromAdditionalService.items) === null || _b === void 0 ? void 0 : _b.length) {
+                    yield this.dataEntityService.bulkCreate(dataFromAdditionalService.items, saveOptions);
+                    if (useResultsForFirstService && !hasFirstServiceResult) {
                         result = dataFromAdditionalService;
                     }
                 }
@@ -140,24 +144,24 @@ class DomainEntityService {
             if (!((_a = this.defaultMethods) === null || _a === void 0 ? void 0 : _a.includes(domain_entity_service_definitions_1.DomainMethod.FindOne))) {
                 throw new definitions_1.ApplicationError(`Method findOne not implemented for class ${typeof this}.`);
             }
-            const _b = options || {}, { optionsOverridesByService, persistanceServices = [domain_entity_service_definitions_1.DomainPersistanceEntityServiceType.Main], saveAdditionalResultsInMain } = _b, otherOptions = __rest(_b, ["optionsOverridesByService", "persistanceServices", "saveAdditionalResultsInMain"]);
-            const [firstServiceName, ...otherServiceNames] = persistanceServices;
-            let result = yield this.getPersistanceService(firstServiceName).findOne(otherOptions, privateOptions);
-            const hasMainServiceResult = typeof result !== 'undefined' && result !== null;
+            const _b = options || {}, { optionsOverridesByService, dataServices = [domain_entity_service_definitions_1.DomainDataEntityServiceType.Main], saveAdditionalResultsInFirstService } = _b, otherOptions = __rest(_b, ["optionsOverridesByService", "dataServices", "saveAdditionalResultsInFirstService"]);
+            const [firstServiceName, ...otherServiceNames] = dataServices;
+            let result = yield this.getDataService(firstServiceName).findOne(otherOptions, privateOptions);
+            const hasFirstServiceResult = typeof result !== 'undefined' && result !== null;
             const resultsByService = yield this.runMethodInAdditionalServices(otherServiceNames || [], {
-                hasMainServiceResult,
-                mainServiceResult: result,
+                firstServiceResult: result,
+                hasFirstServiceResult,
                 methodArgs: [otherOptions, privateOptions],
                 methodName: 'findOne',
                 optionsArgIndex: 0,
                 optionsOverridesByService
             });
-            if (saveAdditionalResultsInMain && resultsByService) {
-                const { saveOptions, serviceName, useResultsAsMain } = saveAdditionalResultsInMain;
+            if (saveAdditionalResultsInFirstService && resultsByService) {
+                const { saveOptions, serviceName, useResultsForFirstService } = saveAdditionalResultsInFirstService;
                 const dataFromAdditionalService = resultsByService[serviceName];
                 if (dataFromAdditionalService) {
-                    yield this.persistanceEntityService.create(dataFromAdditionalService, saveOptions);
-                    if (useResultsAsMain && !hasMainServiceResult) {
+                    yield this.dataEntityService.create(dataFromAdditionalService, saveOptions);
+                    if (useResultsForFirstService && !hasFirstServiceResult) {
                         result = dataFromAdditionalService;
                     }
                 }
@@ -168,14 +172,14 @@ class DomainEntityService {
             };
         });
     }
-    getPersistanceService(serviceName) {
+    getDataService(serviceName) {
         var _a;
-        if (serviceName === domain_entity_service_definitions_1.DomainPersistanceEntityServiceType.Main) {
-            return this.persistanceEntityService;
+        if (serviceName === domain_entity_service_definitions_1.DomainDataEntityServiceType.Main) {
+            return this.dataEntityService;
         }
-        const service = (_a = this.additionalPersistanceEntityServices) === null || _a === void 0 ? void 0 : _a[serviceName];
+        const service = (_a = this.additionalDataEntityServices) === null || _a === void 0 ? void 0 : _a[serviceName];
         if (!service) {
-            throw new definitions_1.ApplicationError(`PersistanceEntityService ${serviceName} does not exist for DomainEntityService ${this.persistanceEntityService.getEntityName()}.`);
+            throw new definitions_1.ApplicationError(`DataEntityService ${serviceName} does not exist for DomainEntityService ${this.dataEntityService.getEntityName(true) || '(no entity name)'}.`);
         }
         return service;
     }
@@ -184,27 +188,28 @@ class DomainEntityService {
             if (!serviceNames.length) {
                 return undefined;
             }
-            const { hasMainServiceResult, mainServiceResult, methodArgs = [], methodName, optionsArgIndex, optionsOverridesByService = {} } = options;
+            const { firstServiceResult, hasFirstServiceResult, methodArgs = [], methodName, optionsArgIndex, optionsOverridesByService = {} } = options;
             const returnDataByService = {};
-            if (!this.additionalPersistanceEntityServices) {
-                throw new definitions_1.ApplicationError(`No additional PersistanceEntityServices exist for DomainEntityService ${this.persistanceEntityService.getEntityName()}.`);
+            if (!this.additionalDataEntityServices) {
+                throw new definitions_1.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 definitions_1.ApplicationError(`Invalid optionsArgIndex value ${optionsArgIndex} provided for DomainEntityService ${this.persistanceEntityService.getEntityName()}.}.`);
+                throw new definitions_1.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.additionalPersistanceEntityServices[serviceName];
+                const service = this.getDataService(serviceName);
                 if (!service) {
-                    throw new definitions_1.ApplicationError(`PersistanceEntityService ${serviceName} does not exist for DomainEntityService ${this.persistanceEntityService.getEntityName()}.`);
+                    throw new definitions_1.ApplicationError(`DataEntityService ${serviceName} does not exist for DomainEntityService ${this.dataEntityService.getEntityName(true) || '(no entity name)'}.`);
                 }
                 const serviceMethodOptionsOverrides = optionsOverridesByService[serviceName] || {};
-                const { filterByMainResultFields, runOnNoMainServiceResultOnly = true } = serviceMethodOptionsOverrides, actualMethodOptionsOverrides = __rest(serviceMethodOptionsOverrides, ["filterByMainResultFields", "runOnNoMainServiceResultOnly"]);
-                if ((runOnNoMainServiceResultOnly === true || runOnNoMainServiceResultOnly === 'true') && hasMainServiceResult) {
+                const { filterByFirstServiceResultFields, runOnNoFirstServiceResultOnly = true } = serviceMethodOptionsOverrides, actualMethodOptionsOverrides = __rest(serviceMethodOptionsOverrides, ["filterByFirstServiceResultFields", "runOnNoFirstServiceResultOnly"]);
+                if ((runOnNoFirstServiceResultOnly === true || runOnNoFirstServiceResultOnly === 'true') &&
+                    hasFirstServiceResult) {
                     continue;
                 }
-                const serviceMethodArgs = immutable_1.default.fromJS(methodArgs).toJS();
+                const serviceMethodArgs = lodash_1.default.cloneDeep(methodArgs);
                 if (typeof serviceMethodArgs[optionsArgIndex] === 'undefined') {
                     if (optionsArgIndex > serviceMethodArgs.length - 1) {
                         serviceMethodArgs.push(actualMethodOptionsOverrides);
@@ -216,18 +221,21 @@ class DomainEntityService {
                 else {
                     serviceMethodArgs[optionsArgIndex] = Object.assign(Object.assign({}, serviceMethodArgs[optionsArgIndex]), actualMethodOptionsOverrides);
                 }
-                if (filterByMainResultFields && Object.keys(filterByMainResultFields).length && hasMainServiceResult) {
+                if (filterByFirstServiceResultFields && Object.keys(filterByFirstServiceResultFields).length) {
+                    if (!hasFirstServiceResult) {
+                        continue;
+                    }
                     const filters = {};
-                    const resultItems = mainServiceResult.items || [
-                        mainServiceResult
+                    const resultItems = firstServiceResult.items || [
+                        firstServiceResult
                     ];
                     resultItems.forEach(resultItem => {
                         if (!resultItem) {
                             return;
                         }
-                        for (const sourceFieldName in filterByMainResultFields) {
+                        for (const sourceFieldName in filterByFirstServiceResultFields) {
                             const fieldValue = resultItem[sourceFieldName];
-                            const targetFieldName = filterByMainResultFields[sourceFieldName];
+                            const targetFieldName = filterByFirstServiceResultFields[sourceFieldName];
                             if (typeof fieldValue === 'undefined') {
                                 return;
                             }
@@ -239,7 +247,7 @@ class DomainEntityService {
                     });
                     if (Object.keys(filters).length) {
                         const serviceMethodOptions = serviceMethodArgs[optionsArgIndex];
-                        serviceMethodArgs[optionsArgIndex] = Object.assign(Object.assign({}, serviceMethodOptions), { filters: Object.assign(Object.assign({}, (0, ramda_1.omit)(['page', 'perPage'], serviceMethodOptions.filters || {})), filters), findAll: true });
+                        serviceMethodArgs[optionsArgIndex] = Object.assign(Object.assign({}, serviceMethodOptions), { filters: Object.assign(Object.assign({}, lodash_1.default.omit(serviceMethodOptions.filters || {}, ['page', 'perPage'])), filters), findAll: true });
                     }
                 }
                 returnDataByService[serviceName] = (yield service[methodName].apply(service, serviceMethodArgs));
@@ -253,14 +261,14 @@ class DomainEntityService {
             if (!((_a = this.defaultMethods) === null || _a === void 0 ? void 0 : _a.includes(domain_entity_service_definitions_1.DomainMethod.Update))) {
                 throw new definitions_1.ApplicationError(`Method update not implemented for class ${typeof this}.`);
             }
-            const { optionsOverridesByService, persistanceServices = [domain_entity_service_definitions_1.DomainPersistanceEntityServiceType.Main] } = options, otherOptions = __rest(options, ["optionsOverridesByService", "persistanceServices"]);
-            const [firstServiceName, ...otherServiceNames] = persistanceServices;
-            const result = yield this.getPersistanceService(firstServiceName).update(data, otherOptions, privateOptions);
+            const { optionsOverridesByService, dataServices = [domain_entity_service_definitions_1.DomainDataEntityServiceType.Main] } = options, otherOptions = __rest(options, ["optionsOverridesByService", "dataServices"]);
+            const [firstServiceName, ...otherServiceNames] = dataServices;
+            const result = yield this.getDataService(firstServiceName).update(data, otherOptions, privateOptions);
             return {
                 result,
                 resultsByService: yield this.runMethodInAdditionalServices(otherServiceNames || [], {
-                    hasMainServiceResult: !!result.count,
-                    mainServiceResult: result,
+                    firstServiceResult: result,
+                    hasFirstServiceResult: !!result.count,
                     methodArgs: [data, otherOptions, privateOptions],
                     methodName: 'update',
                     optionsArgIndex: 1,