dyo-tools 0.1.0 → 0.2.0

package/src/core/DTPlayer.ts

@@ -0,0 +1,57 @@
+import DYOToolsComponentWithMeta from './DTComponentWithMeta';
+import { DTAcceptedMetaData, DTPlayerToObject } from '../types';
+
+export default class DYOToolsPlayer<IComponentMeta extends DTAcceptedMetaData> extends DYOToolsComponentWithMeta<IComponentMeta> {
+  /**
+   * Defining component type to "player".
+   */
+  protected _componentType = 'player';
+
+  /**
+   * Create and return a new DTPlayer instance by applying from current instance :
+   * - Copy _key property
+   * - Copy _meta property
+   *
+   * @returns New DTPlayer instance copied.
+   */
+  copy(): DYOToolsPlayer<IComponentMeta> {
+    const copyElement = new DYOToolsPlayer<IComponentMeta>(this._key, this._options);
+    copyElement.setManyMeta({ ...this.getManyMeta() });
+
+    return copyElement;
+  }
+
+  /**
+   * Return JSON Object representation of the Player instance.
+   *
+   * JSON Object returned has the following structure :
+   * * **id** : _id property of the Player.
+   * * **key** : _key property of the Player.
+   * * **type** : _componentType property of the Player.
+   * * **meta** : JSON Object of all current metadata in _meta property of the Player (only if not empty).
+   *
+   * @returns JSON Object representation of the Player.
+   */
+  toObject(): DTPlayerToObject<IComponentMeta> {
+    const objectPlayer: DTPlayerToObject<IComponentMeta> = {
+      id: this._id,
+      key: this._key,
+      type: this._componentType,
+    };
+
+    if (this._meta && Object.keys(this._meta).length > 0) {
+      objectPlayer.meta = { ...this.getManyMeta() };
+    }
+
+    return objectPlayer;
+  }
+
+  /**
+   * Return String representation of the Player instance.
+   *
+   * @returns String representation of the Player.
+   */
+  toString(): string {
+    return `Component ${this._key} - Type: Player`;
+  }
+}

package/src/index.ts

@@ -0,0 +1,9 @@
+// All exports
+export { default as DTComponent } from './core/DTComponent';
+export { default as DTComponentWithMeta } from './core/DTComponentWithMeta';
+export { default as DTComponentPhysical } from './core/DTComponentPhysical';
+export { default as DTElement } from './core/DTElement';
+export { default as DTBunch } from './core/DTBunch';
+export { default as DTManager } from './core/DTManager';
+export { default as DTPlayer } from './core/DTPlayer';
+export { default as DTError } from './core/DTError';

package/src/libs/DYOFinder.ts

@@ -0,0 +1,175 @@
+import {
+  DYOFinderComponentType,
+  DYOFinderConfiguration,
+  DYOFinderFilterOperator,
+  DYOFinderFilters,
+  FilterOperatorType,
+  StandardPrimitiveType,
+  StandardPrimitiveTypeWithArray,
+} from '../types';
+
+export default class DYOFinder {
+  /**
+   * Current DTComponent associated to the Finder.
+   */
+  protected _component: DYOFinderComponentType;
+
+  /**
+   * Current DYOFinder configuration applied.
+   */
+  protected _configuration: DYOFinderConfiguration;
+
+  /**
+   * Set _component and _configuration properties.
+   *
+   * @param component
+   * @param configuration
+   */
+  constructor(component: DYOFinderComponentType, configuration: DYOFinderConfiguration) {
+    this._component = component;
+    this._configuration = configuration;
+  }
+
+  /**
+   * Getter for _component property.
+   */
+  getComponent(): DYOFinderComponentType {
+    return this._component;
+  }
+
+  /**
+   * Return an array of DTComponent from *_component* **_items** property filtered with a **filters** argument.
+   *
+   * Search filters can be applied on properties depending on the current _configuration provided.
+   *
+   * For each search filter provided, an object of specific operators is applied :
+   * * **BASIC OPERATORS**
+   * * **$eq** : The property must be strict equal to the filter value.
+   * * **$in** : The property must be included into the filter array.
+   * * **$nin** : The property must not be included into the filter array.
+   * * **$ne** : The property must be different to the filter value.
+   * * **EXTENDED OPERATORS** (meta only)
+   * * **$lte** : Number property only. The property must be lower or equal than the filter value.
+   * * **$gte** : Number property only. The property must be higher or equal than the filter array.
+   * * **$contains** : Array property only. The property must contain the filter value.
+   * * **$ncontains** : Array property only. The property must not contain the filter value.
+   *
+   * If many operators and / or many properties are passed into the **filters** argument, the logic operator applied is
+   * **AND**.
+   *
+   * @param filters Filters Object. The format is :
+   * { [property_1] : { [operator_1] : filter_value, [operator_2] : filter_value_2, ... }, [property_2] : { ... }, ... }
+   *
+   * For **objectSearch** properties, you have to pass the object key before the operator :
+   * { [property_1]: { [object_key1] : { [operator_1] : filter_value_1, ... }, [object_key2] : { ... }, ...  }, ... }
+   * @returns Array of DTComponent instance corresponding to the filters. Empty if no filter or invalid ones are passed.
+   */
+  execute<ITEM>(filters: DYOFinderFilters): ITEM[] {
+    const items = this._component.getAll();
+    const filteredItems = [];
+
+    for (const item of items) {
+      let validItem = !!(Object.keys(filters).length);
+
+      for (const [propKey, configProp] of Object.entries(this._configuration)) {
+        if (filters[propKey]) {
+          if (configProp.objectSearch) {
+            const objectValue = configProp.getValue(item, this.getComponent());
+            if (objectValue) {
+              for (const [filterK, filterV] of Object.entries(filters[propKey])) {
+                const metaValue = Object.prototype.hasOwnProperty.call(objectValue, filterK) ? objectValue[filterK] : undefined;
+                if (!this.checkAllValidFiltersForProp(metaValue, filterV, configProp.operators)) {
+                  validItem = false;
+                  break;
+                }
+              }
+            } else {
+              validItem = false;
+            }
+          } else if (!this.checkAllValidFiltersForProp(
+            (configProp.getValue(item, this.getComponent()) as StandardPrimitiveType),
+            filters[propKey],
+            configProp.operators,
+          )) {
+            validItem = false;
+          }
+        }
+      }
+
+      if (validItem) {
+        filteredItems.push(item);
+      }
+    }
+
+    return filteredItems;
+  }
+
+  private checkAllValidFiltersForProp = (
+    itemProp: StandardPrimitiveTypeWithArray,
+    operators: Partial<DYOFinderFilterOperator>,
+    validOperators: FilterOperatorType[],
+  ) => {
+    if (Object.keys(operators).length) {
+      for (const operator of Object.keys(operators)) {
+        if (!validOperators.includes(operator as FilterOperatorType)
+          || !this.validFiltersForItem(itemProp, operators[operator], operator as FilterOperatorType)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    return false;
+  };
+
+  private validFiltersForItem(
+    itemProp: StandardPrimitiveTypeWithArray,
+    filter: StandardPrimitiveTypeWithArray,
+    operator: FilterOperatorType,
+  ): boolean {
+    // $eq Filter
+    if (operator === FilterOperatorType.EQ) {
+      return itemProp === filter;
+    }
+    // $in Filter
+    if (operator === FilterOperatorType.IN) {
+      return filter ? (filter as Array<StandardPrimitiveType>).includes(itemProp as StandardPrimitiveType) : false;
+    }
+    // $nin Filter
+    if (operator === FilterOperatorType.NIN) {
+      return filter ? !(filter as Array<StandardPrimitiveType>).includes(itemProp as StandardPrimitiveType) : false;
+    }
+    // $ne Filter
+    /* c8 ignore next */
+    if (operator === FilterOperatorType.NE) {
+      return itemProp !== filter;
+    }
+    // $lte Filter
+    if (operator === FilterOperatorType.LTE) {
+      if (typeof itemProp === 'number' && typeof filter === 'number') {
+        return itemProp <= filter;
+      }
+      return false;
+    }
+    // $gte Filter
+    if (operator === FilterOperatorType.GTE) {
+      if (typeof itemProp === 'number' && typeof filter === 'number') {
+        return itemProp >= filter;
+      }
+      return false;
+    }
+    // $contains Filter
+    if (operator === FilterOperatorType.CONTAINS) {
+      return (itemProp && Array.isArray(itemProp))
+        ? (itemProp as Array<StandardPrimitiveType>).includes(filter as StandardPrimitiveType)
+        : false;
+    }
+    // $ncontains Filter
+    if (operator === FilterOperatorType.NCONTAINS) {
+      return (itemProp && Array.isArray(itemProp))
+        ? !(itemProp as Array<StandardPrimitiveType>).includes(filter as StandardPrimitiveType)
+        : false;
+    }
+
+    return false;
+  }
+}

package/src/types/index.ts

@@ -0,0 +1,162 @@
+import { DTBunch, DTComponent } from '../index';
+import DYOToolsElement from '../core/DTElement';
+
+/** Constants Enum * */
+export enum FilterOperatorType {
+  EQ = '$eq',
+  IN = '$in',
+  NIN = '$nin',
+  NE = '$ne',
+  LTE = '$lte',
+  GTE = '$gte',
+  CONTAINS = '$contains',
+  NCONTAINS = '$ncontains',
+}
+
+/** Common Types * */
+export type StandardPrimitiveType = string | number | boolean | null | undefined;
+export type StandardPrimitiveTypeWithArray = string | number | boolean | Array<string | number | boolean> | null | undefined;
+
+/** DYO Finder interfaces * */
+export type DYOFinderConfiguration = Record<string, DYOFinderConfigurationProp>;
+export type DYOFinderComponentType = DTComponent & {
+  getAll: () => DTComponent[],
+};
+
+export interface DYOFinderConfigurationPropDefault {
+  operators: FilterOperatorType[],
+  getValue: (item: DTComponent, ctx?: DTComponent) => StandardPrimitiveType,
+  objectSearch: false,
+}
+
+export interface DYOFinderConfigurationPropObjectSearch {
+  operators: FilterOperatorType[],
+  getValue: (item: DTComponent, ctx?: DTComponent) => Record<string, StandardPrimitiveTypeWithArray>,
+  objectSearch: true,
+}
+export type DYOFinderConfigurationProp = DYOFinderConfigurationPropDefault | DYOFinderConfigurationPropObjectSearch;
+
+export interface DYOFinderFilterOperatorBase {
+  [FilterOperatorType.EQ]: StandardPrimitiveType
+  [FilterOperatorType.IN]: Array<StandardPrimitiveType>
+  [FilterOperatorType.NIN]: Array<StandardPrimitiveType>
+  [FilterOperatorType.NE]: StandardPrimitiveType
+}
+export interface DYOFinderFilterOperatorAdvanced {
+  [FilterOperatorType.LTE]: number
+  [FilterOperatorType.GTE]: number
+  [FilterOperatorType.CONTAINS]: StandardPrimitiveType
+  [FilterOperatorType.NCONTAINS]: StandardPrimitiveType
+}
+
+export type DYOFinderFilterOperator = DYOFinderFilterOperatorBase & DYOFinderFilterOperatorAdvanced;
+export type DYOFinderFilterOperatorArgument = Partial<DYOFinderFilterOperator | Record<string, Partial<DYOFinderFilterOperator>>>;
+export type DYOFinderFilters = Record<string, DYOFinderFilterOperatorArgument>;
+
+/** DTComponent interfaces * */
+/**
+ * DTComponent default options configuration.
+ */
+export interface DTComponentOptions {
+  /**
+   * Default *false*. If *true*, no exception is thrown when an error occurred, a new DTError instance is
+   * added to the _errors property array instead. If *false*, throw the exception with a DTError instance.
+   */
+  errors: boolean
+}
+
+export interface DTComponentToObject {
+  id: string
+  key: string
+  type: string
+}
+
+/** DTComponentWithMeta interfaces * */
+export type DTAcceptedMetaData = Record<
+string,
+StandardPrimitiveTypeWithArray
+>;
+
+/** DTElement interfaces * */
+export interface DTElementToObject<IComponentMeta> extends DTComponentToObject {
+  owner?: string
+  meta?: Partial<IComponentMeta>
+}
+
+/** DTBunch interfaces * */
+/**
+ * DTBunch option configuration.
+ */
+export interface DTBunchOptions extends DTComponentOptions {
+  /**
+   * Default *false*. If *true*, an error occurred when adding a new DTElement with the same key of an
+   * existing element into the bunch.
+   */
+  uniqueKey: boolean
+  /**
+   * Default *false*. If *true*, when a new DTElement is added, the owner of this element becomes
+   * automatically the current bunch owner.
+   */
+  replaceIndex: boolean
+  /**
+   * Default *false*. If *true*, the context is not changed when a new DTElement is added.
+   * If *false*, when a new DTElement is added, the context of this element becomes automatically the current bunch instance
+   * and the element is removed from the old context Component (if defined).
+   */
+  inheritOwner: boolean
+  /**
+   * Default *false*. If *true*, when a new DTElement is added at existing index (using **addAtIndex**
+   * or **addManyAtIndex** method), this component replaces the old one. If *false*, this component is added at the specified
+   * index and other existing component are reindexed with the following index.
+   */
+  virtualContext: boolean
+}
+
+export interface DTBunchToObject<IComponentMeta> extends DTComponentToObject {
+  items: Array<DTElementToObject<DTAcceptedMetaData>>
+  owner?: string
+  meta?: Partial<IComponentMeta>
+}
+
+export interface DTBunchFilters {
+  id: Partial<DYOFinderFilterOperatorBase>
+  key: Partial<DYOFinderFilterOperatorBase>
+  context: Partial<DYOFinderFilterOperatorBase>
+  owner: Partial<DYOFinderFilterOperatorBase>
+  meta: Record<string, Partial<DYOFinderFilterOperatorAdvanced>>
+}
+
+/** DTPlayer interfaces * */
+export interface DTPlayerToObject<IComponentMeta> extends DTComponentToObject {
+  meta?: Partial<IComponentMeta>
+}
+
+/** DTManager interfaces * */
+export type DTManagerItemsType<IBunchItem extends DYOToolsElement<DTAcceptedMetaData>> = Record<string, DTManagerItemType<IBunchItem>>;
+export type DTManagerItemType<IBunchItem extends DYOToolsElement<DTAcceptedMetaData>> = {
+  scope: string,
+  item: DTBunch<IBunchItem>,
+};
+
+export interface DTManagerFilters extends DYOFinderFilters {
+  id: Partial<DYOFinderFilterOperatorBase>
+  key: Partial<DYOFinderFilterOperatorBase>
+  owner: Partial<DYOFinderFilterOperatorBase>
+  scope: Partial<DYOFinderFilterOperatorBase>
+  meta: Record<string, Partial<DYOFinderFilterOperatorAdvanced>>
+}
+
+/**
+ * DTManager option configuration.
+ */
+export interface DTManagerOptions extends DTComponentOptions {
+  /**
+   * Default *false*. If *true*, when a bunch instance is removed from the Manager _items, the process performs also
+   * a removal from the Manager Library of all DTElement instances of the bunch.
+   */
+  libraryDeletion: boolean,
+}
+
+export interface DTManagerToObject extends DTComponentToObject {
+  items: Array<DTBunchToObject<DTAcceptedMetaData> & { scope: string }>
+}

package/test/core/DTBunch.double.ts

@@ -0,0 +1,253 @@
+import { DTBunch, DTComponent } from '../../src';
+import { bunchDefaultOptions as DTBunchDefaultOptions } from '../../src/constants';
+import {
+  HaileiMetaData,
+  IldressMetaData,
+  IMetaDataTest,
+  MaydenaMetaData,
+  MeldrineMetaData,
+  YssaliaMetaData,
+} from './DTComponentWithMeta.double';
+import DYOToolsElement from '../../src/core/DTElement';
+import { DTBunchOptions, DTElementToObject } from '../../src/types';
+import Mocked = jest.Mocked;
+import {
+  HaileiIdTest,
+  HaileiKeyTest,
+  HaileiToObjectTest,
+  IldressIdTest,
+  IldressKeyTest,
+  IldressToObjectTest,
+  MaydenaIdTest,
+  MaydenaKeyTest,
+  MaydenaToObjectTest,
+  MeldrineIdTest,
+  MeldrineKeyTest,
+  MeldrineToObjectTest, YssaliaIdTest, YssaliaKeyTest, YssaliaToObjectTest,
+} from './DTElement.double';
+import { DTErrorStub } from './DTError.double';
+import { DTPlayerStub } from './DTPlayer.double';
+import DYOFinder from '../../src/libs/DYOFinder';
+
+/** ****************** STUB PROPERTIES CONSTANTS
+ * Fixed properties to use with double classes, avoid auto generated and easy checking on test
+ * **** */
+// Global Bunch constants
+export const IDTest = 'DTBunch-id-1234567';
+export const IDTestLibrary = 'DTBunch-id-library-1234567';
+export const KeyTest = 'DTBunch-key-1234567';
+export const defaultOptions: DTBunchOptions = DTBunchDefaultOptions;
+
+// Specific Bunch constants
+export const bunch1IdTest = `${IDTest}_1`;
+export const bunch1toObjectTest = {
+  id: bunch1IdTest, key: 'bunch1-key-test', type: 'bunch', items: [HaileiToObjectTest],
+};
+export const bunch2IdTest = `${IDTest}_2`;
+export const bunch2toObjectTest = {
+  id: bunch2IdTest, key: 'bunch2-key-test', type: 'bunch', items: [],
+};
+export const bunch3IdTest = `${IDTest}_3`;
+export const bunch3toObjectTest = {
+  id: bunch3IdTest, key: 'bunch3-key-test', type: 'bunch', items: [],
+};
+
+/** ****************** HELPER TEST CLASS
+ * Helper test class, inherits the main component
+ * Providing methods to property access and other facilities, in order to avoid using class methods
+ * **** */
+export class DTBunchTest extends DTBunch<Mocked<DYOToolsElement<IMetaDataTest>>, IMetaDataTest> {
+  th_get_id(): string {
+    return this._id;
+  }
+
+  th_set_id(id: string): void {
+    this._id = id;
+  }
+
+  th_get_key(): string {
+    return this._key;
+  }
+
+  th_set_key(key: string): void {
+    this._key = key;
+  }
+
+  th_get_componentType(): string {
+    return this._componentType;
+  }
+
+  th_get_context(): DTComponent | undefined {
+    return this._context;
+  }
+
+  th_set_context(context: DTComponent): void {
+    this._context = context;
+  }
+
+  th_get_items(): Mocked<DYOToolsElement<IMetaDataTest>>[] {
+    return this._items;
+  }
+
+  th_set_items(items: Mocked<DYOToolsElement<IMetaDataTest>>[]): void {
+    this._items = items;
+  }
+
+  th_set_errors(errors: Array<DTErrorStub>): void {
+    this._errors = errors;
+  }
+
+  th_get_options(): any {
+    return this._options;
+  }
+
+  th_set_options(options: any): void {
+    this._options = {
+      ...this._options,
+      ...options,
+    };
+  }
+
+  th_get_owner(): DTPlayerStub {
+    return this._owner;
+  }
+
+  th_set_owner(owner: DTPlayerStub): void {
+    this._owner = owner;
+  }
+
+  th_set_meta(meta: IMetaDataTest): void {
+    this._meta = meta;
+  }
+
+  th_get_finder(): DYOFinder {
+    return this._finder;
+  }
+}
+
+/** ****************** STUB CLASS
+ * Stub class, for using in other component
+ * **** */
+export class DTBunchStub extends DTBunchTest {
+  constructor(items: Array<Mocked<DYOToolsElement<IMetaDataTest>>> = []) {
+    super();
+    this._id = IDTest;
+    this._key = KeyTest;
+    this._errors = [];
+    this._items = items;
+    this._options = DTBunchDefaultOptions;
+  }
+
+  getId(): string {
+    return IDTest;
+  }
+
+  getKey(): string {
+    return KeyTest;
+  }
+
+  getAll(): Array<Mocked<DYOToolsElement<IMetaDataTest>>> {
+    return this._items;
+  }
+
+  getAllKeys(): string[] {
+    return this._items.map((item: DYOToolsElement<IMetaDataTest>) => item.getKey());
+  }
+}
+
+// Specific Stub Library for Manager
+export class DTBunchStubLibrary extends DTBunchStub {
+  constructor(items: Array<Mocked<DYOToolsElement<IMetaDataTest>>> = []) {
+    super(items);
+    this._id = IDTestLibrary;
+    this._key = 'library';
+    this._errors = [];
+    this._items = items;
+    this._options = {
+      ...DTBunchDefaultOptions,
+      virtualContext: true,
+    };
+  }
+
+  getId(): string {
+    return IDTestLibrary;
+  }
+
+  getKey(): string {
+    return 'library';
+  }
+
+  get(id: string): Mocked<DYOToolsElement<IMetaDataTest>> | undefined {
+    const itemFiltered = this._items.filter((item: Mocked<DYOToolsElement<IMetaDataTest>>) => item.getId() === id);
+    return itemFiltered.length > 0 ? itemFiltered[0] : undefined;
+  }
+}
+
+/** ****************** HELPER METHODS
+ * Additional helper methods to use with testing
+ * **** */
+
+// Function to generate Mocked DTElement collection
+// Warning : DYOToolsElement class must be MOCKED to use this !
+export const generateMockedElements = (numberElements: number): Array<Mocked<DYOToolsElement<IMetaDataTest>>> => {
+  const mockedElements = [];
+  const mockedData: Array<{ id: string, key: string, meta: IMetaDataTest, toObject: DTElementToObject<IMetaDataTest> }> = [
+    {
+      id: HaileiIdTest,
+      key: HaileiKeyTest,
+      meta: HaileiMetaData,
+      toObject: HaileiToObjectTest,
+    },
+    {
+      id: MeldrineIdTest,
+      key: MeldrineKeyTest,
+      meta: MeldrineMetaData,
+      toObject: MeldrineToObjectTest,
+    },
+    {
+      id: MaydenaIdTest,
+      key: MaydenaKeyTest,
+      meta: MaydenaMetaData,
+      toObject: MaydenaToObjectTest,
+    },
+    {
+      id: IldressIdTest,
+      key: IldressKeyTest,
+      meta: IldressMetaData,
+      toObject: IldressToObjectTest,
+    },
+    {
+      id: YssaliaIdTest,
+      key: YssaliaKeyTest,
+      meta: YssaliaMetaData,
+      toObject: YssaliaToObjectTest,
+    },
+  ];
+
+  for (let i = 0; i < numberElements; i++) {
+    const mockedElement = new DYOToolsElement() as Mocked<DYOToolsElement<IMetaDataTest>>;
+    const selectedMock = i % 5;
+
+    mockedElement.getId.mockReturnValue(`${mockedData[selectedMock].id}-${i}`);
+    mockedElement.getKey.mockReturnValue(mockedData[selectedMock].key);
+    mockedElement.getManyMeta.mockReturnValue(mockedData[selectedMock].meta);
+    mockedElement.setContext.mockImplementation(function (context) {
+      this._context = context;
+    });
+    mockedElement.getContext.mockImplementation(function () {
+      return this._context;
+    });
+    mockedElement.setOwner.mockImplementation(function (owner) {
+      this._owner = owner;
+    });
+    mockedElement.getOwner.mockImplementation(function () {
+      return this._owner;
+    });
+    mockedElement.copy.mockReturnValue(mockedElement);
+    mockedElement.toObject.mockReturnValue(mockedData[selectedMock].toObject);
+
+    mockedElements.push(mockedElement);
+  }
+
+  return mockedElements;
+};