A possible solution is to use ApolloLink:

        // gqlHandleResponse is our handler from the library

        const addDateLink = new ApolloLink((operation, forward) =>
          forward(operation).map(gqlHandleResponse),
        );

        // eslint-disable-next-line unicorn/prefer-spread
        const link = addDateLink.concat(
          httpLink.create({
            uri,
          }),
        );

        return {
          cache: new InMemoryCache(),
          link,
        };

Issue

No typing for gqlFields

export const USER = 'user';

export interface UserEntity {
  id: string;
  firstName: string;
  lastName: string;
}

export interface State extends EntityState<UserEntity> {
  selectedId?: string;
  loaded?: boolean;
  error?: string;
}

export interface PartialState {
  readonly [USER]: State;
}

export const getFeature = createFeatureSelector<PartialState, State>(USER);

export const selectRootUser = rootEntitySelector(getFeature);

export const getUser = selectRootUser({ gqlFields: [''] }); // !Missing suggestions for gqlFields!

Possible sulotion

Provide an ENTITY

declare global {
    export interface SELECTOR_META<ENTITY = any> {
        flatKey?: string;
        gqlFields?: Array<keyof ENTITY>;
    }
}

adjust rootEntitySelector.ts by providing the ENTITY to SELECTOR_META => SELECTOR_META<ENTITY>.

This is how it might look after compilation:

import { FEATURE_SELECTOR, HANDLER_RELATED_ENTITY, HANDLER_ROOT_ENTITY, ID_TYPES, TRANSFORMER } from './types';
export declare function rootEntitySelector<STORE, ENTITY, TRANSFORMED>(featureSelector: FEATURE_SELECTOR<STORE, ENTITY>, transformer: TRANSFORMER<ENTITY, TRANSFORMED>, meta: SELECTOR_META<ENTITY>): (metaOrRelationship?: SELECTOR_META<ENTITY> | HANDLER_RELATED_ENTITY<STORE, ENTITY>, ...relationships: Array<HANDLER_RELATED_ENTITY<STORE, ENTITY>>) => HANDLER_ROOT_ENTITY<STORE, ENTITY, TRANSFORMED, ID_TYPES>;
export declare function rootEntitySelector<STORE, ENTITY, TRANSFORMED>(featureSelector: FEATURE_SELECTOR<STORE, ENTITY>, transformer: TRANSFORMER<ENTITY, TRANSFORMED>): (metaOrRelationship?: SELECTOR_META<ENTITY> | HANDLER_RELATED_ENTITY<STORE, ENTITY>, ...relationships: Array<HANDLER_RELATED_ENTITY<STORE, ENTITY>>) => HANDLER_ROOT_ENTITY<STORE, ENTITY, TRANSFORMED, ID_TYPES>;
export declare function rootEntitySelector<STORE, ENTITY>(featureSelector: FEATURE_SELECTOR<STORE, ENTITY>, meta: SELECTOR_META<ENTITY>): (metaOrRelationship?: SELECTOR_META<ENTITY> | HANDLER_RELATED_ENTITY<STORE, ENTITY>, ...relationships: Array<HANDLER_RELATED_ENTITY<STORE, ENTITY>>) => HANDLER_ROOT_ENTITY<STORE, ENTITY, ENTITY, ID_TYPES>;
export declare function rootEntitySelector<STORE, ENTITY>(featureSelector: FEATURE_SELECTOR<STORE, ENTITY>): (metaOrRelationship?: SELECTOR_META<ENTITY> | HANDLER_RELATED_ENTITY<STORE, ENTITY>, ...relationships: Array<HANDLER_RELATED_ENTITY<STORE, ENTITY>>) => HANDLER_ROOT_ENTITY<STORE, ENTITY, ENTITY, ID_TYPES>;

Profit and a happy developer:

We don't need to guess the entity props any more.

Use all entity props without providing'em all in gqlFields: ['id', '...']

Is it possible to make the gqlFields little more dynamic? For example explicit with gqlFields: 'all' or implicit if gqlFields is not provided, all the entity props are used to generate a graphql query/mutation/subscription.

The only question is, how to handle nested props like:

interface User {
  id: string;
  firstName: string;
  profile: Settings;
}

interface Settings {
  theme: 'light' | 'dark';
  permissions: Permission[];
  // ...
}

interface Permission {
  id: string;
  name: string;
  value: boolean;

Maybe it'd be even cooler with this approach like in prisma

export const getUser = selectRootUser({
  gqlFields: { id: true, firstName: true, profile: { permissions: { value: true } },
});

would generate following graphql query

{
  user {
    id
    firstName
    profile {
      permissions {
        value
      }
    }
  }
}

Add a support to group child entities based on a parent id field.

const e1 = {id: 1};
const e2 = {id: 2, parentId: 1};
const e3 = {id: 3, parentId: 1};

to get

const e = {
  id: 1,
  children: [
    {id:2, parentId: 1},
    {id:3, parentId: 1},
  ],
};

then we can make people happy

There is an error with this repository's Renovate configuration that needs to be fixed. As a precaution, Renovate will stop PRs until it is resolved.

File: e2e/angular10-ivy-false/package.json
Error type: Nested package.json must not contain renovate configuration. Please use packageRules with paths in your main config instead.

On page loading first I dispatch loadMyFiles, this effect executes and populates the store with original data.
When I unlink a file, I dispatch unlinkMyFileSuccess, the effect executes, it sends a request to the backend and received data but doesn't update the store with new data.
The new array of files is pretty similar to the original one, with the only difference in one file record - one or two fields disappear from one record. Not replaced with an undefined, affected object in an array of files is missing this property.

public readonly loadMyFiles$ = createEffect(() =>
    this.actions$.pipe(
      ofType(loadMyFiles, uploadFileSuccess, unlinkMyFileSuccess),
      switchMap(({ cid }) =>
        cidTask(
          cid,
          this.myLibraryFileService.getUploadedFiles().pipe(
            mergeMap((myLibraryFiles: Array<MyLibraryFile>) => [
              cidPayload({
                cid,
                payload: myLibraryFiles.map((myLibraryFile) => myLibraryFile.id),
              }),
              reduceGraph({
                data: myLibraryFiles,
                selector: cpSelectMyFiles,
              }),
            ]),
          ),
        ),
      ),
    ),
  );

Hello,
I have tried your library and it works perfectly.
https://ngrx-entity-relationship.herokuapp.com/user/main

I was looking for a solution for my project, it was not easy to find this library.

I did not understand if the library manages relations:

• many to many
• one to many

how do i associate the staff attribute?

export interface Company {
    id: string;
    name: string;

    staff?: Array<User>; <===== ?????????

    admin?: User;
    adminId?: string;

    address?: Address;
    addressId?: string;
}

Problem

The ngrxEntityRelationshipReducer meta reducer does not work as expected when used along with @ngrx/data.

Here is a stackblitz project to illustrate the behavior:
stackblitz

For these examples say the backend returns that:

{
  "id": "1",
  "firstName": "John",
  "lastName": "Smith",
  "companyId": "1",
  "company": {
    "id": "1",
    "name": "Magic",
    "adminId": "2",
    "addressId": "1",
    "address": {
      "id": "1",
      "street": "Main st.",
      "city": "Town",
      "country": "Land"
    }
  }
}

ngrxEntityRelationshipReducer does update the other entity collections, but since @ngrx/data has already added the response from the server to the entity cache, the entity in the cache still contains the related entities that were in the server response.

So if we dispatch reduceGraph after @ngrx/data loads this user, the entities in entityCache will look like that:

User

{
  "id": "1",
  "firstName": "John",
  "lastName": "Smith",
  "companyId": "1",
  "company": {
    "id": "1",
    "name": "Magic",
    "adminId": "2",
    "addressId": "1",
    "address": {
      "id": "1",
      "street": "Main st.",
      "city": "Town",
      "country": "Land"
    }
  }
}

Company

{
  "id": "1",
  "name": "Magic",
  "adminId": "2",
  "addressId": "1"
}

Address

{
  "id": "1",
  "street": "Main st.",
  "city": "Town",
  "country": "Land"
}

Worth Mentioning

Something to note, @ngrx/data does not automatically initialize the entityCache with empty collections. It starts like that:

{
  entityCache: { }
}

So if we tell @ngrx/data to load a user entity then dispatch reduceGraph on the response, the store will look something like that:

{
  entityCache: {
    User: { ... }
  }
}

The simplest way I found to deal with this is to just add empty arrays into all the entity collections when the app initializes. You can also see this in the stackblitz example.

Here is my case. I have two stores: orders and articles. Order is connected with articles with one to many relation.
artciles contain orderId which is the relational key .
Here is the structure of both objects:

export interface IOrders {
  id: string;
  tableName: string;
  operator: string;
  createdAt: Date;
  elements: IArticles[];
  ...
}

export interface IArticles {
  id: string;
  orderId: string;
  quantity: number;
  article: string;
  description: string;
  status: ArticleStatus
  ...
}

So, what I have into the selectors:
First I need to fetch all articleIds which have a specific status

const allArticleIds = createSelector(selectArticleState, state => Object.values(state.entities)
  .filter(article => [ArticleStatus.ORDERED, ArticleStatus.RETURNED, ArticleStatus.LOCKED, ArticleStatus.CANCELED].includes(article.status))
  .map(article => article.id));

then lets try to create a selector which will return only desired articles:

...
export const selectArticleState = createFeatureSelector<fromArticles.State>('articles');
...
const selectAllOrderedArticles = createSelector(
  s => s,
  // selecting ids
  allOrderedArticleIds,
  selectArticleState,
);

If I create a store selector from the last:

public readonly articles$ = this.store.select(selectAllOrderedArticles);

and subscribe to that, as result will have only the filtered articles. This is great, but now I want to select orders, with their ONLY FILTERED articles! How I can do that?

What I've trying is following:

export const selectOrderState = createFeatureSelector<fromOrders.State>('orders');
...

const selectOrderWithArticles = rootEntity(
  selectOrderState,
  childrenEntities(
    selectAllOrderedArticles,
    'orderId',
    'elements',
  ),
);

const selectOrdersWithArticles = rootEntities(selectOrderWithArticles);

const allOrdersIds = createSelector(selectOrderState, state => state.ids);

const selectAllOrders = createSelector(
  // selecting the whole store
  s => s,
  // selecting ids
  allOrdersIds,
  // selecting all users with desired relationships
  selectOrdersWithArticles,
);

I expected selectOrderWithArticles to return orders with the filtered articles because I've used selectAllOrderedArticles, but actually I receive all articles instead.

Do I have something wrong, or there is a bug in the package?

The goal is to avoid switchMap from the next logic:

store.select(selectCurrentUserId).pipe( // selecting the id of a current user
    switchMap(id => store.select(selectUserWithCompany, id)),  // selecting the user with desired relationships
).subscribe(user => {
     // profit
});

The desired code should look like:

store.select(selectUserWithCompany, selectCurrentUserId).subscribe(user => {
     // profit
});

Let's say I have a Book entity like

interface Book {
 authorId: string;
 author: Author;
 // ...
}

I can use relatedEntitySelector and combine it with rootEntity to get a selector that returns books where the authorId field has been automatically looked up in my Author state to hydrate the author field.

Now let's say that' I have too many authors to load them all upfront. The authorId will most likely not find an entity matching authorId. It would be great to have a way to detect these misses.

I think that what currently happens in the callback defined in relatedEntity is that simply ignore the issue:

        // Line ~120 in relatedEntity.ts
        const valueEntities = [];
        for (const id of ids) {
            if (!featureState.entities[id]) {
                continue; // Ignore related ids that don't appear in the matching feature state
            }

            // ...

            entityValue = {...featureState.entities[id]} as RELATED_ENTITY;

            // ...

            valueEntities.push(entityValue);
        }

Is there any suggestion or best practice to do that? If I haven't missed any build-in functionality, I guess my options are:

• Put all of this logic further down the line once the selectors have returned my entities. Unfortunately at that point I need to define my relationships again, I can't just build upon what I've defined with relatedEntitySelector.
• Re-define relatedEntity and before the above continue statement, do something interesting (most likely call a user-defined function).

Thank you.

Also arrays should be cached too, not only their entities.

The goal is to have possibility to convert entities on all levels.

This issue lists Renovate updates and detected dependencies. Read the Dependency Dashboard docs to learn more.

Datasource	Name	Replacement PR?
npm	@angular/http
npm	@types/redux
npm	codecov
npm	protractor
npm	tslint
npm	tslint-microsoft-contrib

Open

These updates have all been created already. Click a checkbox below to force a retry/rebase of any.

• chore(deps): pin dependency ngrx-entity-relationship to 1.7.1
• chore(deps): update dependency @angular-devkit/architect to v0.1402.13
• chore(deps): update dependency @reduxjs/toolkit to v1.9.7
• chore(deps): update dependency @semantic-release/github to v9.0.7
• chore(deps): update dependency @types/jasmine to v2.8.23
• chore(deps): update dependency @types/jasmine to v2.8.23
• chore(deps): update dependency @types/jasmine to v3.10.18
• chore(deps): update dependency @types/jasmine to v3.10.18
• chore(deps): update dependency @types/jasminewd2 to v2.0.13
• chore(deps): update dependency @types/jasminewd2 to v2.0.13
• chore(deps): update dependency @types/jasminewd2 to v2.0.13
• chore(deps): update dependency @types/jasminewd2 to v2.0.13
• chore(deps): update dependency @types/jasminewd2 to v2.0.13
• chore(deps): update dependency @types/jasminewd2 to v2.0.13
• chore(deps): update dependency @types/jasminewd2 to v2.0.13
• chore(deps): update dependency @types/jasminewd2 to v2.0.13
• chore(deps): update dependency @types/node to v14.18.63
• chore(deps): update dependency @types/node to v14.18.63
• chore(deps): update dependency @types/react-redux to v7.1.33
• chore(deps): update dependency clsx to v2.0.1
• chore(deps): update dependency dotenv to v16.3.2
• chore(deps): update dependency jasmine-core to v4.6.1
• chore(deps): update dependency karma to v6.4.3
• chore(deps): update dependency postcss to v8.4.40
• chore(deps): update dependency ts-node to v10.9.2
• chore(deps): update dependency ts-node to v10.9.2
• chore(deps): update dependency ts-node to v10.9.2
• chore(deps): update dependency tslib to v2.5.3
• chore(deps): update dependency tslib to v2.6.3
• chore(deps): update dependency tslib to v2.6.3
• chore(deps): update dependency tslib to v2.6.3
• chore(deps): update dependency tslib to v2.6.3
• chore(deps): update dependency zone.js to v0.13.3
• chore(deps): update docusaurus monorepo to v2.0.1 (patch) (@docusaurus/core, @docusaurus/plugin-content-docs, @docusaurus/plugin-google-gtag, @docusaurus/plugin-sitemap, @docusaurus/theme-classic)
• chore(deps): update react monorepo (patch) (@types/react, @types/react-dom)
• chore(deps): update satantime/puppeteer-node docker tag to v16.20.2
• chore(deps): update commitlint monorepo to v17.8.1 (minor) (@commitlint/cli, @commitlint/config-conventional)
• chore(deps): update dependency @angular-devkit/architect to v0.1801.2
• chore(deps): update dependency @semantic-release/github to v9.2.6
• chore(deps): update dependency clsx to v2.1.1
• chore(deps): update dependency dotenv to v16.4.5
• chore(deps): update dependency eslint to v8.57.0
• chore(deps): update dependency lint-staged to v13.3.0
• chore(deps): update dependency puppeteer to v13.7.0
• chore(deps): update dependency tslib to v2.6.3
• chore(deps): update dependency typescript to v4.9.5
• chore(deps): update dependency zone.js to v0.14.8
• chore(deps): update docusaurus monorepo to v2.4.3 (minor) (@docusaurus/core, @docusaurus/plugin-content-docs, @docusaurus/plugin-google-gtag, @docusaurus/plugin-sitemap, @docusaurus/theme-classic)
• chore(deps): update react monorepo to v18.3.1 (minor) (react, react-dom)
• chore(deps): update angular monorepo to v13 (major) (@angular/animations, @angular/common, @angular/compiler, @angular/compiler-cli, @angular/core, @angular/forms, @angular/language-service, @angular/platform-browser, @angular/platform-browser-dynamic, @angular/router)
• chore(deps): update angular monorepo to v14 (major) (@angular/animations, @angular/common, @angular/compiler, @angular/compiler-cli, @angular/core, @angular/forms, @angular/language-service, @angular/platform-browser, @angular/platform-browser-dynamic, @angular/router)
• chore(deps): update angular monorepo to v15 (major) (@angular/animations, @angular/common, @angular/compiler, @angular/compiler-cli, @angular/core, @angular/forms, @angular/language-service, @angular/platform-browser, @angular/platform-browser-dynamic, @angular/router)
• chore(deps): update angular monorepo to v16 (major) (@angular/animations, @angular/common, @angular/compiler, @angular/compiler-cli, @angular/core, @angular/forms, @angular/language-service, @angular/platform-browser, @angular/platform-browser-dynamic, @angular/router)
• chore(deps): update angular monorepo to v17 (major) (@angular/animations, @angular/common, @angular/compiler, @angular/compiler-cli, @angular/core, @angular/forms, @angular/language-service, @angular/platform-browser, @angular/platform-browser-dynamic, @angular/router)
• chore(deps): update angular monorepo to v18 (major) (@angular/animations, @angular/common, @angular/compiler, @angular/compiler-cli, @angular/core, @angular/forms, @angular/language-service, @angular/platform-browser, @angular/platform-browser-dynamic, @angular/router)
• chore(deps): update commitlint monorepo to v18 (major) (@commitlint/cli, @commitlint/config-conventional)
• chore(deps): update commitlint monorepo to v19 (major) (@commitlint/cli, @commitlint/config-conventional)
• chore(deps): update dependency @angular-devkit/build-angular to v13
• chore(deps): update dependency @angular-devkit/build-angular to v14
• chore(deps): update dependency @angular-devkit/build-angular to v15
• chore(deps): update dependency @angular-devkit/build-angular to v16
• chore(deps): update dependency @angular-devkit/build-angular to v17
• chore(deps): update dependency @angular-devkit/build-angular to v18
• chore(deps): update dependency @mdx-js/react to v2
• chore(deps): update dependency @mdx-js/react to v3
• chore(deps): update dependency @semantic-release/github to v10
• chore(deps): update dependency @types/jasmine to v4
• chore(deps): update dependency @types/jasmine to v5
• chore(deps): update dependency eslint to v9
• chore(deps): update dependency husky to v9
• chore(deps): update dependency jasmine-core to v5
• chore(deps): update dependency karma-jasmine to v5
• chore(deps): update dependency lint-staged to v14
• chore(deps): update dependency lint-staged to v15
• chore(deps): update dependency ng-packagr to v13
• chore(deps): update dependency ng-packagr to v14
• chore(deps): update dependency ng-packagr to v15
• chore(deps): update dependency ng-packagr to v16
• chore(deps): update dependency ng-packagr to v17
• chore(deps): update dependency ng-packagr to v18
• chore(deps): update dependency node to v16 (node, @types/node)
• chore(deps): update dependency node to v18 (node, @types/node)
• chore(deps): update dependency node to v20 (node, @types/node)
• chore(deps): update dependency prettier to v3
• chore(deps): update dependency puppeteer to v18
• chore(deps): update dependency puppeteer to v19
• chore(deps): update dependency puppeteer to v20
• chore(deps): update dependency puppeteer to v21
• chore(deps): update dependency puppeteer to v22
• chore(deps): update dependency semantic-release to v20
• chore(deps): update dependency semantic-release to v21
• chore(deps): update dependency semantic-release to v22
• chore(deps): update dependency semantic-release to v23
• chore(deps): update dependency semantic-release to v24
• chore(deps): update dependency typescript to v5
• chore(deps): update dependency win to v5
• chore(deps): update docusaurus monorepo to v3 (major) (@docusaurus/core, @docusaurus/plugin-content-docs, @docusaurus/plugin-google-gtag, @docusaurus/plugin-sitemap, @docusaurus/theme-classic)
• chore(deps): update nrwl monorepo to v13 (major) (@nrwl/angular, @nrwl/cli, @nrwl/tao, @nrwl/workspace)
• chore(deps): update nrwl monorepo to v14 (major) (@nrwl/angular, @nrwl/cli, @nrwl/tao, @nrwl/workspace)
• chore(deps): update nrwl monorepo to v15 (major) (@nrwl/angular, @nrwl/cli, @nrwl/tao, @nrwl/workspace)
• chore(deps): update nrwl monorepo to v16 (major) (@nrwl/angular, @nrwl/tao, @nrwl/workspace)
• chore(deps): update nrwl monorepo to v17 (major) (@nrwl/angular, @nrwl/tao, @nrwl/workspace)
• chore(deps): update nrwl monorepo to v18 (major) (@nrwl/angular, @nrwl/tao, @nrwl/workspace)
• chore(deps): update nrwl monorepo to v19 (major) (@nrwl/angular, @nrwl/tao, @nrwl/workspace)
• chore(deps): update satantime/puppeteer-node docker tag to v17
• chore(deps): update satantime/puppeteer-node docker tag to v18
• chore(deps): update satantime/puppeteer-node docker tag to v19
• chore(deps): update satantime/puppeteer-node docker tag to v20
• Click on this checkbox to rebase all open PRs at once

Detected dependencies

• Check this box to trigger a request for Renovate to run again on this repository

Hi,
first thank you for this awesome library, you really helped me out there when trying to implement entity relations with ngrx/data! I am currently integrating it into my app and stumbled upon how to add the ngrxEntityRelationshipReducer to the root import. So far I have

import { ngrxEntityRelationshipReducer } from 'ngrx-entity-relationship';

StoreModule.forRoot(reducers, {
      metaReducers: [
        ngrxEntityRelationshipReducer
      ],
      //...
    }),

but I get this error on startup:

ERROR in app/app.module.ts(99,9): Error during template compile of 'AppModule' Only initialized variables and constants can be referenced in decorators because the value of this variable is needed by the template compiler in 'ngrxEntityRelationshipReducer' 'ngrxEntityRelationshipReducer' references 'ngrxEntityRelationshipReducer' 'ngrxEntityRelationshipReducer' references 'ngrxEntityRelationshipReducer' 'ngrxEntityRelationshipReducer' is not initialized.

Unfortunately I couldn't find any examples in the Hero/Villain/Fight examples to check how you used it. Do you have any advice?

There may happen cases, when we don't shan't to send a shape as gql query. For example, it's Frontend only selection.

This rel should be marked as gqlIgnore flag and should be skipped during query building.

I am using ngrx-entity-relationship in my angular project with @ngrx/store.

When I try to use reduceGraph inside an effect, no change occurs in the store, and when I check the devtool I see that the selector is not reaching

this is the effect code

loadPostById$ = createEffect(() =>
    this.actions$.pipe(
      ofType(PostActions.loadPostById),
      concatMap(({ id }) =>
        this.postService.loadPostById(id).pipe(
          map((post) => reduceGraph({
            data: post,
            selector: rootPost()
          })),
          catchError((error) => of(PostActions.loadPostByIdFailure({ error })))
        )
      )
    )
  );

this is the relationships code

export const rootPost = rootEntitySelector(fromPosts.selectPostsState);
export const relPostUser = relatedEntitySelector(
  fromUsers.selectUsersState,
  'publisherId',
  'publisher'
)

This is what i see in devtool, it has no selector this is what i see in the devtool

Along with usage of feature selectors would be great to support root selector factories too.

In such a case, the rel selector would simply extract feature selector, I'd selector and spread meta data (gql fields etc).

This lib is awesome! Thank you!

Trying to load entities with @ngrx/data requesting a graphql server but don't know how to init the loading process. This isn't mentioned in the docs https://ngrx-entity-relationship.sudo.eu/guide/ngrx-data.

Basically I have configured @ngrx/data user service and user selector service.

How to call a graphql end point to get users using user selector service?

Hi,

Awesome library! I am currently looking to use your library to select a list of all entities from two entity caches using NgRx Data.

Currently, I have something like:

export const selectUser = rootEntity(
this.entityCache.users, // the selector of the user's feature.

 // now we define a relationship between a user and a company.
relatedEntity(
selectCompanyState, // a selector of the company's feature.
'companyId', // the key in the user's model that points to the company's id.
'company', // the key in the user's model that should be fulfilled with the company's entity.
),
);

I want to be able to do something like the below which will select all users and associated company.

export const selectUsers = rootEntities(selectUser);

But it seems to be wanting an id or list of ids to filter by.

Is it possible with this library to return all?

Hi,
in the README.md file, the "real usage example" links don't work.

GitHub issue

In Angular 12 selectors with props are deprecated.

The suggested way of selecting the entities mentioned in quick steps would therefore be deprecated as well:

const selectUsers = rootEntities(selectUser);

// NGRX
this.store.select(this.selectUsers, ['1', '2']);

The suggested way of rewriting according to the github issue is to use factory selector like this:

export const users = (ids: number[]) => createSelector(this.selectUsers, (users) => {
    return ... code to select users by ids
});

// Then consume it as
this.store.select(users(['1', '2']));

Currently this is not possible because the rootEntity and rootEntities requires ids as an argument and it matches the following overload in NGRX so it is also flagged as deprecated:

/**
 * @deprecated Selectors with props are deprecated, for more info see {@link https://github.com/ngrx/platform/issues/2980 Github Issue}
 */
export declare function createSelector<State, Props, S1, Result>(s1: SelectorWithProps<State, Props, S1>, projector: (s1: S1, props: Props) => Result): MemoizedSelectorWithProps<State, Props, Result>;

The first argument is of type

export declare type SelectorWithProps<State, Props, Result> = (state: State, props: Props) => Result;

which matches (for rootEntities) your type HANDLER_ROOT_ENTITIES because it contains (state, id): Array

export type HANDLER_ROOT_ENTITIES<S, E, T, I> = ENTITY_SELECTOR<S, E> & {
    (state: S, id: undefined | null | Array<I> | STORE_SELECTOR<S, undefined | null | Array<I>>): Array<T>;
};

Would it be possible to rewrite the rootEntity and rootEntities functions and/or create new ones for filtering by ids so that something like the following would work?

/** Code in ngrx-entity-relationship */
export function findByIds(state, ids): {
   .. code to filter by IDs
   return entities;
} 

/** Code in user apps */
const selectAllUsers = rootEntities(selectUser);
const selectUsersById = (ids) => createSelector(selectAllUsers, (state) => findByIds(state, ids));

this.store.select(selectUsersById(['1', '2']));

The idea is to move the arguments into the functions itself to avoid selector with properties.

if the id field hasn't been set, then we should detect its values based on the related entity and populate its value.

So

parentId: null,
parent: {
  id: 123,
},

would become in the store

parentId: 123,

the same for sets.