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

package/src/common/utils/setNested/setNested.spec.ts

@@ -0,0 +1,184 @@
+import { strict as assert } from 'assert';
+
+import { setNested } from '../../dist';
+
+describe('setNested', function () {
+  it('should execute successfully and return false if an empty string field argument is provided', function () {
+    const result = setNested({}, '', true);
+    assert.strictEqual(result, false, `bad value ${result} for the method execution result, expected false`);
+  });
+  it('should execute successfully and return false if a step in the path does not exist in the parent', function () {
+    const result = setNested({}, 'foo.bar', true);
+    assert.strictEqual(result, false, `bad value ${result} for the method execution result, expected false`);
+  });
+  it('should execute successfully, set the child field and return true if the field does exist in the parent and there are no arrays in the path', function () {
+    const inputObject = { foo: {} } as any,
+      result = setNested(inputObject, 'foo.bar', 'test');
+    assert.strictEqual(result, true, `bad value ${result} for the method execution result, expected ${true}`);
+    assert.strictEqual(
+      inputObject.foo.bar,
+      'test',
+      `bad value ${inputObject.foo.bar} for the method execution inputObject.foo.bar, expected ${'test'}`
+    );
+  });
+  it('should execute successfully, set the child field and return true if the field exists in the parent and there are no arrays in the path', function () {
+    const inputObject = { foo: { bar: 'oldTest' } } as any,
+      result = setNested(inputObject, 'foo.bar', 'test');
+    assert.strictEqual(result, true, `bad value ${result} for the method execution result, expected ${true}`);
+    assert.strictEqual(
+      inputObject.foo.bar,
+      'test',
+      `bad value ${inputObject.foo.bar} for the method execution inputObject.foo.bar, expected ${'test'}`
+    );
+  });
+  it('should execute successfully, set the child field and return true if the field exists in the parent, there are arrays in the path and an index for them is provided', function () {
+    const inputObject = { foo: [{ bar: 'test1' }, { bar: 'test2' }] },
+      result = setNested(inputObject, 'foo.0.bar', 'test');
+    assert.strictEqual(result, true, `bad value ${result} for the method execution result, expected ${true}`);
+    assert.strictEqual(
+      inputObject.foo[0].bar,
+      'test',
+      `bad value ${inputObject.foo[0].bar} for the method execution inputObject.foo[0].bar, expected ${'test'}`
+    );
+    assert.strictEqual(
+      inputObject.foo[1].bar,
+      'test2',
+      `bad value ${inputObject.foo[1].bar} for the method execution inputObject.foo[1].bar, expected ${'test2'}`
+    );
+  });
+  it('should execute successfully, set the child field and return true if the field exists in the parent, there are arrays in the path and an index for them is not provided', function () {
+    const inputObject = { foo: [{ bar: 'test1' }, { bar: 'test2' }] },
+      result = setNested(inputObject, 'foo.bar', 'test');
+    assert.strictEqual(result, true, `bad value ${result} for the method execution result, expected ${true}`);
+    assert.strictEqual(
+      inputObject.foo[0].bar,
+      'test',
+      `bad value ${inputObject.foo[0].bar} for the method execution inputObject.foo[0].bar, expected ${'test'}`
+    );
+    assert.strictEqual(
+      inputObject.foo[1].bar,
+      'test',
+      `bad value ${inputObject.foo[1].bar} for the method execution inputObject.foo[1].bar, expected ${'test'}`
+    );
+  });
+  it('should execute successfully, set the child field and return true if the field does exist in the parent, there is an $ in the path and there are no arrays in the path', function () {
+    const inputObject = { foo: {} } as any,
+      result = setNested(inputObject, 'foo.$bar', 'test');
+    assert.strictEqual(result, true, `bad value ${result} for the method execution result, expected ${true}`);
+    assert.strictEqual(
+      inputObject.foo['$bar'],
+      'test',
+      `bad value ${inputObject.foo['$bar']} for the method execution inputObject.foo['$bar'], expected ${'test'}`
+    );
+  });
+  it('should execute successfully, set the child field and return true if the field exists in the parent, there is an $ in the path and there are no arrays in the path', function () {
+    const inputObject = { foo: { $bar: 'oldTest' } } as any,
+      result = setNested(inputObject, 'foo.$bar', 'test');
+    assert.strictEqual(result, true, `bad value ${result} for the method execution result, expected ${true}`);
+    assert.strictEqual(
+      inputObject.foo['$bar'],
+      'test',
+      `bad value ${inputObject.foo['$bar']} for the method execution inputObject.foo['$bar'], expected ${'test'}`
+    );
+  });
+  it('should execute successfully, set the child field and return true if the field exists in the parent, there is an $ in the path, there are arrays in the path and an index for them is provided', function () {
+    const inputObject = { foo: [{ $bar: 'test1' }, { $bar: 'test2' }] },
+      result = setNested(inputObject, 'foo.0.$bar', 'test');
+    assert.strictEqual(result, true, `bad value ${result} for the method execution result, expected ${true}`);
+    assert.strictEqual(
+      inputObject.foo[0]['$bar'],
+      'test',
+      `bad value ${inputObject.foo[0]['$bar']} for the method execution inputObject.foo[0]['$bar'], expected ${'test'}`
+    );
+    assert.strictEqual(
+      inputObject.foo[1]['$bar'],
+      'test2',
+      `bad value ${inputObject.foo[1]['$bar']} for the method execution inputObject.foo[1]['$bar'], expected ${'test2'}`
+    );
+  });
+  it('should execute successfully, set the child field and return true if the field exists in the parent, there is an $ in the path, there are arrays in the path and an index for them is not provided', function () {
+    const inputObject = { foo: [{ $bar: 'test1' }, { $bar: 'test2' }] },
+      result = setNested(inputObject, 'foo.$bar', 'test');
+    assert.strictEqual(result, true, `bad value ${result} for the method execution result, expected ${true}`);
+    assert.strictEqual(
+      inputObject.foo[0]['$bar'],
+      'test',
+      `bad value ${inputObject.foo[0]['$bar']} for the method execution inputObject.foo[0]['$bar'], expected ${'test'}`
+    );
+    assert.strictEqual(
+      inputObject.foo[1]['$bar'],
+      'test',
+      `bad value ${inputObject.foo[1]['$bar']} for the method execution inputObject.foo[1]['$bar'], expected ${'test'}`
+    );
+  });
+  it('should execute successfully, set the child field and return true if the field does exist in the parent, there is an $$ in the path and an $ in the path, and there are no arrays in the path', function () {
+    const inputObject = { foo: { $bar: {} } } as any,
+      result = setNested(inputObject, 'foo.$bar.$q.boo.baz$', 'test');
+    assert.strictEqual(result, true, `bad value ${result} for the method execution result, expected ${true}`);
+    assert.strictEqual(
+      inputObject.foo['$bar']['$q.boo.baz$'],
+      'test',
+      `bad value ${inputObject.foo['$bar']['$q.boo.baz$']} for the method execution inputObject.foo['$bar']['$q.boo.baz$'], expected ${'test'}`
+    );
+  });
+  it('should execute successfully, set the child field and return true if the field does exist in the parent, there is an $$ in the path and there are no arrays in the path', function () {
+    const inputObject = { foo: {} } as any,
+      result = setNested(inputObject, 'foo.$bar.baz$', 'test');
+    assert.strictEqual(result, true, `bad value ${result} for the method execution result, expected ${true}`);
+    assert.strictEqual(
+      inputObject.foo['$bar.baz$'],
+      'test',
+      `bad value ${inputObject.foo['$bar.baz$']} for the method execution inputObject.foo['$bar.baz$'], expected ${'test'}`
+    );
+  });
+  it('should execute successfully, set the child field and return true if the field exists in the parent, there is an $$ in the path, there are no arrays in the path and the $$ item is the last item', function () {
+    const inputObject = { foo: { '$bar.baz$': 'oldTest' } } as any,
+      result = setNested(inputObject, 'foo.$bar.baz$', 'test');
+    assert.strictEqual(result, true, `bad value ${result} for the method execution result, expected ${true}`);
+    assert.strictEqual(
+      inputObject.foo['$bar.baz$'],
+      'test',
+      `bad value ${inputObject.foo['$bar.baz$']} for the method execution inputObject.foo['$bar.baz$'], expected ${'test'}`
+    );
+  });
+  it('should execute successfully, set the child field and return true if the field exists in the parent, there is an $$ in the path, there are no arrays in the path and the $$ item is not the last item', function () {
+    const inputObject = { foo: { '$bar.baz$': { boo: 'oldTest' } } } as any,
+      result = setNested(inputObject, 'foo.$bar.baz$.boo', 'test');
+    assert.strictEqual(result, true, `bad value ${result} for the method execution result, expected ${true}`);
+    assert.strictEqual(
+      inputObject.foo['$bar.baz$'].boo,
+      'test',
+      `bad value ${inputObject.foo['$bar.baz$'].boo} for the method execution inputObject.foo['$bar.baz$'].boo, expected ${'test'}`
+    );
+  });
+  it('should execute successfully, set the child field and return true if the field exists in the parent, there is an $$ in the path, there are arrays in the path and an index for them is provided', function () {
+    const inputObject = { foo: [{ '$bar.baz$': 'test1' }, { '$bar.baz$': 'test2' }] },
+      result = setNested(inputObject, 'foo.0.$bar.baz$', 'test');
+    assert.strictEqual(result, true, `bad value ${result} for the method execution result, expected ${true}`);
+    assert.strictEqual(
+      inputObject.foo[0]['$bar.baz$'],
+      'test',
+      `bad value ${inputObject.foo[0]['$bar.baz$']} for the method execution inputObject.foo[0]['$bar.baz$'], expected ${'test'}`
+    );
+    assert.strictEqual(
+      inputObject.foo[1]['$bar.baz$'],
+      'test2',
+      `bad value ${inputObject.foo[1]['$bar.baz$']} for the method execution inputObject.foo[1]['$bar.baz$'], expected ${'test2'}`
+    );
+  });
+  it('should execute successfully, set the child field and return true if the field exists in the parent, there is an $$ in the path, there are arrays in the path and an index for them is not provided', function () {
+    const inputObject = { foo: [{ '$bar.baz$': 'test1' }, { '$bar.baz$': 'test2' }] },
+      result = setNested(inputObject, 'foo.$bar.baz$', 'test');
+    assert.strictEqual(result, true, `bad value ${result} for the method execution result, expected ${true}`);
+    assert.strictEqual(
+      inputObject.foo[0]['$bar.baz$'],
+      'test',
+      `bad value ${inputObject.foo[0]['$bar.baz$']} for the method execution inputObject.foo[0]['$bar.baz$'], expected ${'test'}`
+    );
+    assert.strictEqual(
+      inputObject.foo[1]['$bar.baz$'],
+      'test',
+      `bad value ${inputObject.foo[1]['$bar.baz$']} for the method execution inputObject.foo[1]['$bar.baz$'], expected ${'test'}`
+    );
+  });
+});

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

@@ -0,0 +1,154 @@
+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 enum DataOrderByDirection {
+  // eslint-disable-next-line no-unused-vars
+  Asc = 'ASC',
+  // eslint-disable-next-line no-unused-vars
+  Desc = 'DESC'
+}
+
+export enum DataSelectOperator {
+  // eslint-disable-next-line no-unused-vars
+  Between = '$between',
+  // eslint-disable-next-line no-unused-vars
+  Contains = '$contains',
+  // eslint-disable-next-line no-unused-vars
+  Equals = '$eq',
+  // eslint-disable-next-line no-unused-vars
+  GreaterThan = '$gt',
+  // eslint-disable-next-line no-unused-vars
+  GreaterThanOrEqual = '$gte',
+  // eslint-disable-next-line no-unused-vars
+  LessThan = '$lt',
+  // eslint-disable-next-line no-unused-vars
+  LessThanOrEqual = '$lte',
+  // eslint-disable-next-line no-unused-vars
+  Like = '$like',
+  // eslint-disable-next-line no-unused-vars
+  ILike = '$ilike',
+  // eslint-disable-next-line no-unused-vars
+  Not = '$not',
+  // eslint-disable-next-line no-unused-vars
+  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 enum ProcessObjectAllowedFieldsType {
+  // eslint-disable-next-line no-unused-vars
+  Filters = 'processFiltersAllowedFieldsEnabled',
+  // eslint-disable-next-line no-unused-vars
+  Input = 'processInputAllowedFieldsEnabled'
+}

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

@@ -0,0 +1,112 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+
+import { DataEntityService } from './data.entity.service';
+import {
+  DataDeleteOptions,
+  DataFindOneOptions,
+  DataFindOptions,
+  DataUpdateOptions
+} from './data.entity.service.definitions';
+
+import { ApplicationError } from '../../common/definitions';
+
+// Define a dummy entity interface for testing.
+interface DummyEntity {
+  id: number;
+  value: string;
+}
+
+// Optionally, define a subclass that does not override the methods.
+class DummyDataEntityService extends DataEntityService<DummyEntity> {}
+
+describe('DataEntityService Base Class', () => {
+  let service: DataEntityService<DummyEntity>;
+
+  beforeEach(() => {
+    service = new DataEntityService<DummyEntity>();
+  });
+
+  describe('bulkCreate', () => {
+    it('should throw an ApplicationError with "bulkCreate" in the message', async () => {
+      await expect(service.bulkCreate([{ id: 1, value: 'test' }])).rejects.toThrow(ApplicationError);
+      await expect(service.bulkCreate([{ id: 1, value: 'test' }])).rejects.toThrow(/bulkCreate/);
+    });
+  });
+
+  describe('create', () => {
+    it('should throw an ApplicationError with "create" in the message', async () => {
+      await expect(service.create({ id: 2, value: 'test' })).rejects.toThrow(ApplicationError);
+      await expect(service.create({ id: 2, value: 'test' })).rejects.toThrow(/create/);
+    });
+  });
+
+  describe('count', () => {
+    it('should throw an ApplicationError with "count" in the message', async () => {
+      const dummyOptions: DataFindOptions = {} as DataFindOptions;
+      await expect(service.count(dummyOptions)).rejects.toThrow(ApplicationError);
+      await expect(service.count(dummyOptions)).rejects.toThrow(/count/);
+    });
+  });
+
+  describe('delete', () => {
+    it('should throw an ApplicationError with "delete" in the message', () => {
+      const dummyOptions: DataDeleteOptions = {} as DataDeleteOptions;
+      expect(() => service.delete(dummyOptions)).toThrow(ApplicationError);
+      expect(() => service.delete(dummyOptions)).toThrow(/delete/);
+    });
+  });
+
+  describe('find', () => {
+    it('should throw an ApplicationError with "find" in the message', () => {
+      const dummyOptions: DataFindOptions = {} as DataFindOptions;
+      expect(() => service.find(dummyOptions)).toThrow(ApplicationError);
+      expect(() => service.find(dummyOptions)).toThrow(/find/);
+    });
+  });
+
+  describe('findOne', () => {
+    it('should throw an ApplicationError with "findOne" in the message', () => {
+      const dummyOptions: DataFindOneOptions = {} as DataFindOneOptions;
+      expect(() => service.findOne(dummyOptions)).toThrow(ApplicationError);
+      expect(() => service.findOne(dummyOptions)).toThrow(/findOne/);
+    });
+  });
+
+  describe('update', () => {
+    it('should throw an ApplicationError with "update" in the message', async () => {
+      const dummyData: DummyEntity = { id: 3, value: 'test' };
+      const dummyOptions: DataUpdateOptions = {} as DataUpdateOptions;
+      await expect(service.update(dummyData, dummyOptions)).rejects.toThrow(ApplicationError);
+      await expect(service.update(dummyData, dummyOptions)).rejects.toThrow(/update/);
+    });
+  });
+});
+
+describe('DummyDataEntityService Subclass', () => {
+  let service: DummyDataEntityService;
+
+  beforeEach(() => {
+    service = new DummyDataEntityService();
+  });
+  it('bulkCreate should throw an error with "bulkCreate" in the message', async () => {
+    await expect(service.bulkCreate([{ id: 10, value: 'dummy' }])).rejects.toThrow(/bulkCreate/);
+  });
+  it('create should throw an error with "create" in the message', async () => {
+    await expect(service.create({ id: 11, value: 'dummy' })).rejects.toThrow(/create/);
+  });
+  it('count should throw an error with "count" in the message', async () => {
+    await expect(service.count({} as DataFindOptions)).rejects.toThrow(/count/);
+  });
+  it('delete should throw an error with "delete" in the message', () => {
+    expect(() => service.delete({} as DataDeleteOptions)).toThrow(/delete/);
+  });
+  it('find should throw an error with "find" in the message', () => {
+    expect(() => service.find({} as DataFindOptions)).toThrow(/find/);
+  });
+  it('findOne should throw an error with "findOne" in the message', () => {
+    expect(() => service.findOne({} as DataFindOneOptions)).toThrow(/findOne/);
+  });
+  it('update should throw an error with "update" in the message', async () => {
+    await expect(service.update({ id: 12, value: 'dummy' }, {} as DataUpdateOptions)).rejects.toThrow(/update/);
+  });
+});

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

@@ -0,0 +1,144 @@
+import {
+  DataBulkCreatePrivateOptions,
+  DataCountPrivateOptions,
+  DataCreatePrivateOptions,
+  DataDefaultData,
+  DataDeleteOptions,
+  DataDeletePrivateOptions,
+  DataDeleteResult,
+  DataFindOneOptions,
+  DataFindOnePrivateOptions,
+  DataFindOptions,
+  DataFindPrivateOptions,
+  DataFindResults,
+  DataUpdateOptions,
+  DataUpdatePrivateOptions,
+  DataUpdateResult,
+  ProcessObjectAllowedFieldsOptions
+} from './data.entity.service.definitions';
+
+import {
+  AppConfigCommonData,
+  AppConfigCommonDataEntityServiceSettings,
+  ConfigProviderService
+} from '../../common/configProvider';
+import { ApplicationError } from '../../common/definitions';
+
+/*
+ * This class is used as a unifying abstraction between RDB and non-RDB entities. It can be used
+ * to define classes that are agnostic of the type of persitance.
+ */
+export abstract class DataEntityService<Entity, Data extends DataDefaultData<Entity> = DataDefaultData<Entity>> {
+  protected settings: AppConfigCommonDataEntityServiceSettings;
+
+  constructor(
+    protected configProvider: ConfigProviderService,
+    protected dataModuleName: string
+  ) {
+    const { settingsPerEntity } = configProvider.config.data[dataModuleName] as AppConfigCommonData;
+    this.settings = settingsPerEntity || {};
+  }
+
+  public async bulkCreate(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _data: Data['BulkCreate'],
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _options?: unknown,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _privateOptions?: DataBulkCreatePrivateOptions
+  ): Promise<Entity[]> {
+    throw new ApplicationError(`Method bulkCreate not implemented for class ${typeof this}.`);
+  }
+
+  public async count(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _options: DataFindOptions,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _privateOptions?: DataCountPrivateOptions
+  ): Promise<number | undefined> {
+    throw new ApplicationError(`Method count not implemented for class ${typeof this}.`);
+  }
+
+  public async create(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _data: Data['Create'],
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _options?: unknown,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _privateOptions?: DataCreatePrivateOptions
+  ): Promise<Entity> {
+    throw new ApplicationError(`Method create not implemented for class ${typeof this}.`);
+  }
+
+  public delete(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _options: DataDeleteOptions,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _privateOptions?: DataDeletePrivateOptions
+  ): Promise<DataDeleteResult<Entity>> {
+    throw new ApplicationError(`Method delete not implemented for class ${typeof this}.`);
+  }
+
+  public find(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _options: DataFindOptions,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _privateOptions?: DataFindPrivateOptions
+  ): Promise<DataFindResults<Entity>> {
+    throw new ApplicationError(`Method find not implemented for class ${typeof this}.`);
+  }
+
+  public findOne(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _options: DataFindOneOptions,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _privateOptions?: DataFindOnePrivateOptions
+  ): Promise<Entity | null> {
+    throw new ApplicationError(`Method findOne not implemented for class ${typeof this}.`);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public getEntityName(noError?: boolean): string | null {
+    if (noError) {
+      return null;
+    }
+    throw new ApplicationError(`Method getEntityName not implemented for class ${typeof this}.`);
+  }
+
+  // TODO: handle relations' fields
+  protected async processObjectAllowedFields<Data = Partial<Entity>>(
+    data: Data | Data[],
+    options: ProcessObjectAllowedFieldsOptions
+  ): Promise<Data | Data[]> {
+    const { settings } = this;
+    const { allowedFields, isEnabled, objectType } = options;
+    if (isEnabled === false || (typeof isEnabled === 'undefined' && !settings[objectType as keyof typeof settings])) {
+      return data;
+    }
+    const actualData = data instanceof Array ? data : [data];
+    const processedData: Data[] = [];
+    actualData.forEach(dataItem => {
+      const processedDataItem = {} as Data;
+      allowedFields.forEach(fieldName => {
+        const typedFieldName = fieldName as unknown as keyof Data;
+        const value = dataItem[typedFieldName];
+        if (typeof value !== 'undefined') {
+          processedDataItem[typedFieldName] = value;
+        }
+      });
+      processedData.push(processedDataItem);
+    });
+    return processedData.length === 1 ? processedData[0] : processedData;
+  }
+
+  public async update(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _data: Data['Update'],
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _options: DataUpdateOptions,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _privateOptions?: DataUpdatePrivateOptions
+  ): Promise<DataUpdateResult<Entity>> {
+    throw new ApplicationError(`Method update not implemented for class ${typeof this}.`);
+  }
+}

package/src/data/entityService/index.ts

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