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

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

@@ -0,0 +1,19 @@
+import { DataBulkCreatePrivateOptions, DataCountPrivateOptions, DataCreatePrivateOptions, DataDefaultData, DataDeleteOptions, DataDeletePrivateOptions, DataDeleteResult, DataFindOneOptions, DataFindOnePrivateOptions, DataFindOptions, DataFindPrivateOptions, DataFindResults, DataUpdateOptions, DataUpdatePrivateOptions, DataUpdateResult, ProcessObjectAllowedFieldsOptions } from './data.entity.service.definitions';
+import { AppConfigCommonDataEntityServiceSettings, ConfigProviderService } from '../../common/configProvider';
+import { LoggerService } from '../../common/logger';
+export declare abstract class DataEntityService<Entity, Data extends DataDefaultData<Entity> = DataDefaultData<Entity>> {
+    protected configProvider: ConfigProviderService;
+    protected dataModuleName: string;
+    protected logger: LoggerService;
+    protected settings: AppConfigCommonDataEntityServiceSettings;
+    constructor(configProvider: ConfigProviderService, dataModuleName: string, logger: LoggerService);
+    bulkCreate(_data: Data['BulkCreate'], _options?: unknown, _privateOptions?: DataBulkCreatePrivateOptions): Promise<Entity[]>;
+    count(_options: DataFindOptions, _privateOptions?: DataCountPrivateOptions): Promise<number | undefined>;
+    create(_data: Data['Create'], _options?: unknown, _privateOptions?: DataCreatePrivateOptions): Promise<Entity>;
+    delete(_options: DataDeleteOptions, _privateOptions?: DataDeletePrivateOptions): Promise<DataDeleteResult<Entity>>;
+    find(_options: DataFindOptions, _privateOptions?: DataFindPrivateOptions): Promise<DataFindResults<Entity>>;
+    findOne(_options: DataFindOneOptions, _privateOptions?: DataFindOnePrivateOptions): Promise<Entity | null>;
+    getEntityName(noError?: boolean): string | null;
+    protected processObjectAllowedFields<Data = Partial<Entity>>(data: Data | Data[], options: ProcessObjectAllowedFieldsOptions): Promise<Data | Data[]>;
+    update(_data: Data['Update'], _options: DataUpdateOptions, _privateOptions?: DataUpdatePrivateOptions): Promise<DataUpdateResult<Entity>>;
+}

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

@@ -0,0 +1,117 @@
+import { GenericObject } from '../../common/definitions';
+export interface DataBulkCreatePrivateOptions extends GenericObject {
+    processInputAllowedFieldsEnabled?: boolean;
+}
+export interface DataCountOptions {
+    filters?: GenericObject;
+    findAll?: boolean;
+    include?: string[];
+    withDeleted?: boolean;
+}
+export interface DataCountPrivateOptions extends GenericObject {
+    allowCountWithoutFilters?: boolean;
+    processFiltersAllowedFieldsEnabled?: boolean;
+}
+export interface DataCreatePrivateOptions {
+    processInputAllowedFieldsEnabled?: boolean;
+}
+export interface DataDefaultData<Entity> {
+    BulkCreate: Partial<Entity>[];
+    Create: Partial<Entity>;
+    Update: Partial<Entity>;
+}
+export interface DataDeleteOptions {
+    filters: GenericObject;
+    returnOriginalItems?: boolean;
+    softDelete?: boolean;
+}
+export interface DataDeletePrivateOptions extends GenericObject {
+    processFiltersAllowedFieldsEnabled?: boolean;
+    requirePrimaryKeys?: boolean;
+}
+export interface DataDeleteResult<Item> {
+    count?: number;
+    originalItems?: Item[];
+}
+export interface DataFindOneOptions {
+    filters: GenericObject;
+    include?: string[];
+    orderBy?: GenericObject<DataOrderByDirection>;
+    select?: string[];
+    selectOperator?: DataSelectOperator;
+    withDeleted?: boolean;
+}
+export interface DataFindOnePrivateOptions extends GenericObject {
+    processFiltersAllowedFieldsEnabled?: boolean;
+}
+export interface DataFindOptions {
+    filters?: GenericObject;
+    findAll?: boolean;
+    getTotalCount?: boolean;
+    include?: string[];
+    individualSearch?: boolean;
+    orderBy?: GenericObject<DataOrderByDirection>;
+    page?: number;
+    perPage?: number;
+    select?: string[];
+    withDeleted?: boolean;
+}
+export interface DataFindPrivateOptions extends GenericObject {
+    processFiltersAllowedFieldsEnabled?: boolean;
+}
+export interface DataFindResults<Item> {
+    items: Item[];
+    more: boolean;
+    page: number;
+    perPage: number;
+    totalCount?: number;
+}
+export type DataRelationItem<Data> = {
+    deleted?: boolean;
+} & Data;
+export interface DataOrderBy {
+    field: string;
+    direction: DataOrderByDirection;
+}
+export declare enum DataOrderByDirection {
+    Asc = "ASC",
+    Desc = "DESC"
+}
+export declare enum DataSelectOperator {
+    Between = "$between",
+    Contains = "$contains",
+    Equals = "$eq",
+    GreaterThan = "$gt",
+    GreaterThanOrEqual = "$gte",
+    LessThan = "$lt",
+    LessThanOrEqual = "$lte",
+    Like = "$like",
+    ILike = "$ilike",
+    Not = "$not",
+    Or = "$or"
+}
+export interface DataUpdateOptions {
+    filters: GenericObject;
+    returnData?: boolean;
+    returnOriginalItems?: boolean;
+}
+export interface DataUpdatePrivateOptions extends GenericObject {
+    processFiltersAllowedFieldsEnabled?: boolean;
+    processInputAllowedFieldsEnabled?: boolean;
+    requirePrimaryKeys?: boolean;
+    withDeleted?: boolean;
+}
+export interface DataUpdateResult<Item> {
+    count?: number;
+    items?: Item[];
+    originalItems?: Item[];
+}
+export interface ProcessObjectAllowedFieldsOptions {
+    allowedFields: string[];
+    isEnabled?: boolean;
+    objectType: string;
+}
+export declare enum ProcessObjectAllowedFieldsType {
+    Filters = "processFiltersAllowedFieldsEnabled",
+    Input = "processInputAllowedFieldsEnabled"
+}

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessObjectAllowedFieldsType = exports.DataSelectOperator = exports.DataOrderByDirection = void 0;
+var DataOrderByDirection;
+(function (DataOrderByDirection) {
+    DataOrderByDirection["Asc"] = "ASC";
+    DataOrderByDirection["Desc"] = "DESC";
+})(DataOrderByDirection || (exports.DataOrderByDirection = DataOrderByDirection = {}));
+var DataSelectOperator;
+(function (DataSelectOperator) {
+    DataSelectOperator["Between"] = "$between";
+    DataSelectOperator["Contains"] = "$contains";
+    DataSelectOperator["Equals"] = "$eq";
+    DataSelectOperator["GreaterThan"] = "$gt";
+    DataSelectOperator["GreaterThanOrEqual"] = "$gte";
+    DataSelectOperator["LessThan"] = "$lt";
+    DataSelectOperator["LessThanOrEqual"] = "$lte";
+    DataSelectOperator["Like"] = "$like";
+    DataSelectOperator["ILike"] = "$ilike";
+    DataSelectOperator["Not"] = "$not";
+    DataSelectOperator["Or"] = "$or";
+})(DataSelectOperator || (exports.DataSelectOperator = DataSelectOperator = {}));
+var ProcessObjectAllowedFieldsType;
+(function (ProcessObjectAllowedFieldsType) {
+    ProcessObjectAllowedFieldsType["Filters"] = "processFiltersAllowedFieldsEnabled";
+    ProcessObjectAllowedFieldsType["Input"] = "processInputAllowedFieldsEnabled";
+})(ProcessObjectAllowedFieldsType || (exports.ProcessObjectAllowedFieldsType = ProcessObjectAllowedFieldsType = {}));
+//# sourceMappingURL=data.entity.service.definitions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"data.entity.service.definitions.js","sourceRoot":"","sources":["../../../src/data/entityService/data.entity.service.definitions.ts"],"names":[],"mappings":";;;AA2FA,IAAY,oBAKX;AALD,WAAY,oBAAoB;IAE9B,mCAAW,CAAA;IAEX,qCAAa,CAAA;AACf,CAAC,EALW,oBAAoB,oCAApB,oBAAoB,QAK/B;AAED,IAAY,kBAuBX;AAvBD,WAAY,kBAAkB;IAE5B,0CAAoB,CAAA;IAEpB,4CAAsB,CAAA;IAEtB,oCAAc,CAAA;IAEd,yCAAmB,CAAA;IAEnB,iDAA2B,CAAA;IAE3B,sCAAgB,CAAA;IAEhB,8CAAwB,CAAA;IAExB,oCAAc,CAAA;IAEd,sCAAgB,CAAA;IAEhB,kCAAY,CAAA;IAEZ,gCAAU,CAAA;AACZ,CAAC,EAvBW,kBAAkB,kCAAlB,kBAAkB,QAuB7B;AA2BD,IAAY,8BAKX;AALD,WAAY,8BAA8B;IAExC,gFAA8C,CAAA;IAE9C,4EAA0C,CAAA;AAC5C,CAAC,EALW,8BAA8B,8CAA9B,8BAA8B,QAKzC"}

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

@@ -9,22 +9,29 @@ 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, logger) {
+        this.configProvider = configProvider;
+        this.dataModuleName = dataModuleName;
+        this.logger = logger;
+        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 +43,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":";;;;;;;;;;;;AAwBA,0DAA4D;AAO5D,MAAsB,iBAAiB;IAGrC,YACY,cAAqC,EACrC,cAAsB,EAEtB,MAAqB;QAHrB,mBAAc,GAAd,cAAc,CAAuB;QACrC,mBAAc,GAAd,cAAc,CAAQ;QAEtB,WAAM,GAAN,MAAM,CAAe;QAE/B,MAAM,EAAE,iBAAiB,EAAE,GAAG,cAAc,CAAC,MAAM,CAAC,IAAI,CAAC,cAAc,CAAwB,CAAC;QAChG,IAAI,CAAC,QAAQ,GAAG,iBAAiB,IAAI,EAAE,CAAC;IAC1C,CAAC;IAEY,UAAU,CAErB,KAAyB,EAEzB,QAAkB,EAElB,eAA8C;;YAE9C,MAAM,IAAI,8BAAgB,CAAC,+CAA+C,OAAO,IAAI,GAAG,CAAC,CAAC;QAC5F,CAAC;KAAA;IAEY,KAAK,CAEhB,QAAyB,EAEzB,eAAyC;;YAEzC,MAAM,IAAI,8BAAgB,CAAC,0CAA0C,OAAO,IAAI,GAAG,CAAC,CAAC;QACvF,CAAC;KAAA;IAEY,MAAM,CAEjB,KAAqB,EAErB,QAAkB,EAElB,eAA0C;;YAE1C,MAAM,IAAI,8BAAgB,CAAC,2CAA2C,OAAO,IAAI,GAAG,CAAC,CAAC;QACxF,CAAC;KAAA;IAEM,MAAM,CAEX,QAA2B,EAE3B,eAA0C;QAE1C,MAAM,IAAI,8BAAgB,CAAC,2CAA2C,OAAO,IAAI,GAAG,CAAC,CAAC;IACxF,CAAC;IAEM,IAAI,CAET,QAAyB,EAEzB,eAAwC;QAExC,MAAM,IAAI,8BAAgB,CAAC,yCAAyC,OAAO,IAAI,GAAG,CAAC,CAAC;IACtF,CAAC;IAEM,OAAO,CAEZ,QAA4B,EAE5B,eAA2C;QAE3C,MAAM,IAAI,8BAAgB,CAAC,4CAA4C,OAAO,IAAI,GAAG,CAAC,CAAC;IACzF,CAAC;IAGM,aAAa,CAAC,OAAiB;QACpC,IAAI,OAAO,EAAE,CAAC;YACZ,OAAO,IAAI,CAAC;QACd,CAAC;QACD,MAAM,IAAI,8BAAgB,CAAC,kDAAkD,OAAO,IAAI,GAAG,CAAC,CAAC;IAC/F,CAAC;IAGe,0BAA0B,CACxC,IAAmB,EACnB,OAA0C;;YAE1C,MAAM,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC;YAC1B,MAAM,EAAE,aAAa,EAAE,SAAS,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC;YACzD,IAAI,SAAS,KAAK,KAAK,IAAI,CAAC,OAAO,SAAS,KAAK,WAAW,IAAI,CAAC,QAAQ,CAAC,UAAmC,CAAC,CAAC,EAAE,CAAC;gBAChH,OAAO,IAAI,CAAC;YACd,CAAC;YACD,MAAM,UAAU,GAAG,IAAI,YAAY,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;YACzD,MAAM,aAAa,GAAW,EAAE,CAAC;YACjC,UAAU,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;gBAC5B,MAAM,iBAAiB,GAAG,EAAU,CAAC;gBACrC,aAAa,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE;oBAChC,MAAM,cAAc,GAAG,SAAkC,CAAC;oBAC1D,MAAM,KAAK,GAAG,QAAQ,CAAC,cAAc,CAAC,CAAC;oBACvC,IAAI,OAAO,KAAK,KAAK,WAAW,EAAE,CAAC;wBACjC,iBAAiB,CAAC,cAAc,CAAC,GAAG,KAAK,CAAC;oBAC5C,CAAC;gBACH,CAAC,CAAC,CAAC;gBACH,aAAa,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;YACxC,CAAC,CAAC,CAAC;YACH,OAAO,aAAa,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC;QACvE,CAAC;KAAA;IAEY,MAAM,CAEjB,KAAqB,EAErB,QAA2B,EAE3B,eAA0C;;YAE1C,MAAM,IAAI,8BAAgB,CAAC,2CAA2C,OAAO,IAAI,GAAG,CAAC,CAAC;QACxF,CAAC;KAAA;CACF;AAnHD,8CAmHC"}

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,34 @@
-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 { LoggerService } from '../../common/logger';
+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 logger: LoggerService;
+    protected additionalDataEntityServices?: AdditionalEntityServices | undefined;
+    protected defaultAdditionalDataEntityServicesOptions?: {
+        [methodName: string]: {
+            [serviceName: string]: {
+                allowIncoming?: boolean;
+                serviceOptions?: DomainBaseAdditionalServiceOptionsOverrides & GenericObject<unknown>;
+            };
+        };
+    } | undefined;
+    constructor(dataEntityService: EntityService, defaultMethods: string[] | undefined, logger: LoggerService, 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"}