fix: Fixes entity update functions.

Author: ryasmi

src/functions/countEntities.ts

@@ -5,8 +5,8 @@ import filterEntities from '../utils/filterEntities';
 
 export default <E extends Entity>(config: Config<E>): CountEntities<E> => {
   return async ({ filter = {} }) => {
-    const storedEntities = config.getEntities();
-    const matchedEntities = filterEntities(storedEntities, filter);
+    const entities = config.getEntities();
+    const matchedEntities = filterEntities({ entities, filter });
     const count = matchedEntities.length;
     return { count };
   };

src/functions/createEntity.ts

@@ -5,16 +5,20 @@ import Filter from '@js-entity-repos/core/dist/types/Filter';
 import Config from '../Config';
 import filterEntities from '../utils/filterEntities';
 
-export default <E extends Entity>(config: Config<E>): CreateEntity<E> => {
+export default <E extends Entity>({
+  entityName,
+  getEntities,
+  setEntities,
+}: Config<E>): CreateEntity<E> => {
   return async ({ id, entity }) => {
-    const storedEntities = config.getEntities();
+    const entities = getEntities();
     const idFilter = { id } as Filter<E>;
-    const matchedEntities = filterEntities(storedEntities, idFilter);
+    const matchedEntities = filterEntities({ entities, filter: idFilter });
     if (matchedEntities.length > 0) {
-      throw new ConflictingEntityError(config.entityName, id);
+      throw new ConflictingEntityError(entityName, id);
     }
     const createdEntity = { ...entity as any, id };
-    config.setEntities([...config.getEntities(), createdEntity]);
+    setEntities([...entities, createdEntity]);
     return { entity: createdEntity };
   };
 };

src/functions/getEntities.ts

@@ -19,8 +19,8 @@ export default <E extends Entity>(config: Config<E>): GetEntities<E> => {
     const paginationFilter = createPaginationFilter(pagination, sort);
     const fullFilter = { $and: [filter, paginationFilter] };
     const storedEntities = config.getEntities();
-    const matchedEntities = filterEntities(storedEntities, fullFilter);
-    const sortedEntities = sortEntities(matchedEntities, sort);
+    const matchedEntities = filterEntities({ entities: storedEntities, filter: fullFilter });
+    const sortedEntities = sortEntities({ entities: matchedEntities, sort });
     const start = pagination.forward ? 0 : 0 - pagination.limit;
     const end = pagination.forward ? pagination.limit : undefined;
     const entities = sortedEntities.slice(start, end);

src/functions/getEntity.ts

@@ -3,9 +3,13 @@ import Entity from '@js-entity-repos/core/dist/types/Entity';
 import Config from '../Config';
 import filterEntity from '../utils/filterEntity';
 
-export default <E extends Entity>(config: Config<E>): GetEntity<E> => {
+export default <E extends Entity>({
+  entityName,
+  getEntities,
+}: Config<E>): GetEntity<E> => {
   return async ({ id, filter = {} }) => {
-    const entity = filterEntity(config, id, filter);
+    const entities = getEntities();
+    const entity = filterEntity({ entities, entityName, id, filter });
     return { entity };
   };
 };

src/functions/patchEntity.ts

@@ -4,13 +4,17 @@ import { difference } from 'lodash';
 import Config from '../Config';
 import filterEntity from '../utils/filterEntity';
 
-export default <E extends Entity>(config: Config<E>): PatchEntity<E> => {
+export default <E extends Entity>({
+  entityName,
+  getEntities,
+  setEntities,
+}: Config<E>): PatchEntity<E> => {
   return async ({ id, patch, filter = {} }) => {
-    const storedEntities = config.getEntities();
-    const matchedEntity = filterEntity(config, id, filter);
+    const entities = getEntities();
+    const matchedEntity = filterEntity({ entities, entityName, id, filter });
     const patchedEntity = { ...matchedEntity as any, ...patch as any } as E;
-    const unmatchedEntities = difference(storedEntities, [matchedEntity]);
-    config.setEntities([...unmatchedEntities, patchedEntity]);
+    const unmatchedEntities = difference(entities, [matchedEntity]);
+    setEntities([...unmatchedEntities, patchedEntity]);
     return { entity: patchedEntity };
   };
 };

src/functions/removeEntities.ts

@@ -5,8 +5,9 @@ import filterEntities from '../utils/filterEntities';
 
 export default <E extends Entity>(config: Config<E>): RemoveEntities<E> => {
   return async ({ filter = {} }) => {
-    const storedEntities = config.getEntities();
-    const unmatchedEntities = filterEntities(storedEntities, { $nor: [filter] });
+    const entities = config.getEntities();
+    const removalFilter = { $nor: [filter] };
+    const unmatchedEntities = filterEntities({ entities, filter: removalFilter });
     config.setEntities(unmatchedEntities);
   };
 };

src/functions/removeEntity.ts

@@ -8,15 +8,16 @@ import filterEntities from '../utils/filterEntities';
 
 export default <E extends Entity>(config: Config<E>): RemoveEntity<E> => {
   return async ({ id, filter = {} }) => {
-    const storedEntities = config.getEntities();
+    const entities = config.getEntities();
     const idFilter = { id } as Filter<E>;
     const fullFilter = { $and: [idFilter, filter] };
-    const unmatchedEntities = filterEntities(storedEntities, { $nor: [fullFilter] });
-    if (unmatchedEntities.length === storedEntities.length) {
+    const removalFilter = { $nor: [fullFilter] };
+    const unmatchedEntities = filterEntities({ entities, filter: removalFilter });
+    if (unmatchedEntities.length === entities.length) {
       throw new MissingEntityError(config.entityName, id);
     }
     /* istanbul ignore next */
-    if ((unmatchedEntities.length + 1) !== storedEntities.length) {
+    if ((unmatchedEntities.length + 1) !== entities.length) {
       throw new ConflictingEntityError(config.entityName, id);
     }
     config.setEntities(unmatchedEntities);

src/functions/replaceEntity.ts

@@ -4,13 +4,17 @@ import { difference } from 'lodash';
 import Config from '../Config';
 import filterEntity from '../utils/filterEntity';
 
-export default <E extends Entity>(config: Config<E>): ReplaceEntity<E> => {
+export default <E extends Entity>({
+  entityName,
+  getEntities,
+  setEntities,
+}: Config<E>): ReplaceEntity<E> => {
   return async ({ id, entity, filter = {} }) => {
-    const storedEntities = config.getEntities();
-    const matchedEntity = filterEntity(config, id, filter);
+    const entities = getEntities();
+    const matchedEntity = filterEntity({ entities, entityName, id, filter });
     const replacedEntity = { ...entity as any, id } as E;
-    const unmatchedEntities = difference(storedEntities, [matchedEntity]);
-    config.setEntities([...unmatchedEntities, replacedEntity]);
+    const unmatchedEntities = difference(entities, [matchedEntity]);
+    setEntities([...unmatchedEntities, replacedEntity]);
     return { entity: replacedEntity };
   };
 };

src/utils/filterEntities.ts

@@ -3,7 +3,12 @@ import Entity from '@js-entity-repos/core/dist/types/Entity';
 import { ConditionFilter, Filter, PropFilter } from '@js-entity-repos/core/dist/types/Filter';
 import sift from 'sift';
 
-export default <E extends Entity>(entities: E[], filter: Filter<E>) => {
+export interface Opts<E extends Entity> {
+  readonly entities: E[];
+  readonly filter: Filter<E>;
+}
+
+export default <E extends Entity>({ entities, filter }: Opts<E>) => {
   const sifter = sift(filter as any);
   return entities.filter(sifter);
 };

src/utils/filterEntity.ts

@@ -2,20 +2,25 @@ import ConflictingEntityError from '@js-entity-repos/core/dist/errors/Conflictin
 import MissingEntityError from '@js-entity-repos/core/dist/errors/MissingEntityError';
 import Entity from '@js-entity-repos/core/dist/types/Entity';
 import Filter from '@js-entity-repos/core/dist/types/Filter';
-import Config from '../Config';
 import filterEntities from './filterEntities';
 
-export default <E extends Entity>(config: Config<E>, id: string, filter: Filter<E>) => {
-  const storedEntities = config.getEntities();
+export interface Opts<E extends Entity> {
+  readonly entities: E[];
+  readonly entityName: string;
+  readonly id: string;
+  readonly filter: Filter<E>;
+}
+
+export default <E extends Entity>({ entities, entityName, id, filter }: Opts<E>) => {
   const idFilter = { id } as Filter<E>;
   const fullFilter = { $and: [idFilter, filter] };
-  const matchedEntities = filterEntities(storedEntities, fullFilter);
+  const matchedEntities = filterEntities({ entities, filter: fullFilter });
   if (matchedEntities.length === 0) {
-    throw new MissingEntityError(config.entityName, id);
+    throw new MissingEntityError(entityName, id);
   }
   /* istanbul ignore next */
   if (matchedEntities.length > 1) {
-    throw new ConflictingEntityError(config.entityName, id);
+    throw new ConflictingEntityError(entityName, id);
   }
   return matchedEntities[0];
 };