Function createEntityStore

core/store.ts:73–319

(
  definition: EntityDefinition<Data, View>,
  db: ClientDb,
  cleanup: CleanupObject
)

 * This allows distinguishing between 'system' and 'user' events where user is only making changes with client.
 */
export function createEntityStore<Data, View>(
  definition: EntityDefinition<Data, View>,
  db: ClientDb,
  cleanup: CleanupObject
): EntityStore<Data, View> {
  type StoreEntity = Entity<Data, View>;

  const { config } = definition;
  /**
   * Keep 2 'versions' of items list. Array and id<>item map for quick 'by id' access.
   */
  const items = observable.array<StoreEntity>([]);
  const itemsMap = observable.object<Record<string, Entity<Data, View>>>({});

  const getIsEntityAccessable =
    config.rootFilter &&
    cachedComputed(function getIsEntityAccessable(entity: StoreEntity) {
      return config.rootFilter!(entity, db);
    });

  const getRootSource = cachedComputed(
    function getSourceForQueryInput(): Entity<Data, View>[] {
      let output = items as StoreEntity[];

      if (config.rootFilter) {
        output = output.filter((entity) => getIsEntityAccessable!(entity));
      }

      return output;
    },
    { equals: areArraysShallowEqual }
  );

  const sortItems = cachedComputed((items: StoreEntity[]) => {
    if (!config.defaultSort) {
      return items;
    }

    return sortBy(items, config.defaultSort);
  });

  const allItems = cachedComputedWithoutArgs(() => {
    return sortItems(getRootSource());
  });

  const propIndexMap = new Map<
    keyof Data | keyof View,
    QueryIndex<Data, View, IndexableKey<Data & View>>
  >();

  function getEntityId(entity: Entity<Data, View>) {
    const id = `${entity[config.idField!]}`;

    return id;
  }

  const createOrReuseQuery = deepMemoize(
    function createOrReuseQuery(