chore: wip resource snapshots for withEntityResource

Author: michael-small

libs/ngrx-toolkit/src/lib/with-entity-resources.spec.ts

@@ -7,6 +7,7 @@ import {
   setAllEntities,
 } from '@ngrx/signals/entities';
 import { withEntityResources } from './with-entity-resources';
+import { withPreviousValue } from './with-resource/tests/util/snapshot';
 
 type Todo = { id: number; title: string; completed: boolean };
 const wait = (ms = 0) => new Promise((r) => setTimeout(r, ms));
@@ -199,6 +200,49 @@ describe('withEntityResources', () => {
       ]);
     });
 
+    it('does not support setAllEntities/addEntity/removeEntity for unnamed which are of type Resource', async () => {
+      const Store = signalStore(
+        { providedIn: 'root', protectedState: false },
+        withEntityResources(() =>
+          withPreviousValue(
+            resource({
+              loader: () => Promise.resolve([] as Todo[]),
+              defaultValue: [],
+            }),
+          ),
+        ),
+      );
+      const store = TestBed.inject(Store);
+
+      await wait();
+
+      const invalidSetAll = () =>
+        patchState(
+          store,
+          // @ts-expect-error Resources which are of type Resource should not support entity updaters
+          setAllEntities([
+            { id: 1, title: 'A', completed: false },
+            { id: 2, title: 'B', completed: true },
+          ] as Todo[]),
+        );
+
+      const invalidAdd = () =>
+        patchState(
+          store,
+          // @ts-expect-error Resources which are of type Resource should not support entity updaters
+          addEntity({ id: 3, title: 'C', completed: false } as Todo),
+        );
+
+      // @ts-expect-error Resources which are of type Resource should not support entity updaters
+      const invalidRemove = () => patchState(store, removeEntity(2));
+
+      expect(invalidSetAll).toBeDefined();
+      expect(invalidAdd).toBeDefined();
+      expect(invalidRemove).toBeDefined();
+      expect(store.ids()).toEqual([]);
+      expect(store.entities()).toEqual([]);
+    });
+
     it('supports setAllEntities/addEntity/removeEntity for named', async () => {
       const Store = signalStore(
         { providedIn: 'root', protectedState: false },

libs/ngrx-toolkit/src/lib/with-entity-resources.ts

@@ -4,6 +4,7 @@ import {
   ResourceSnapshot,
   ResourceStatus,
   Signal,
+  computed,
   isSignal,
   linkedSignal,
 } from '@angular/core';
@@ -14,6 +15,7 @@ import {
   signalStoreFeature,
   withComputed,
   withLinkedState,
+  withProps,
 } from '@ngrx/signals';
 import {
   EntityId,
@@ -103,7 +105,16 @@ export function withEntityResources<
 >(
   resourceFactory: (
     store: Input['props'] & Input['methods'] & StateSignals<Input['state']>,
-  ) => WidenedResource<TypedEntityResourceValue<Entity>>,
+  ) => ResourceRef<TypedEntityResourceValue<Entity>>,
+): SignalStoreFeature<Input, EntityResourceRefResult<Entity>>;
+
+export function withEntityResources<
+  Input extends SignalStoreFeatureResult,
+  Entity extends { id: EntityId },
+>(
+  resourceFactory: (
+    store: Input['props'] & Input['methods'] & StateSignals<Input['state']>,
+  ) => Resource<TypedEntityResourceValue<Entity>>,
 ): SignalStoreFeature<Input, EntityResourceResult<Entity>>;
 
 export function withEntityResources<
@@ -131,7 +142,7 @@ export function withEntityResources<
     });
 
     if (isResourceRef(resourceOrDict)) {
-      return createUnnamedEntityResource(resourceOrDict)(store);
+      return createUnnamedEntityResourceRef(resourceOrDict)(store);
     } else if (isResource(resourceOrDict)) {
       return createUnnamedEntityResource(resourceOrDict)(store);
     }
@@ -145,10 +156,8 @@ export function withEntityResources<
  * because {@link withResource} creates a Proxy around the resource value
  * to avoid the error throwing behavior of the Resource API.
  */
-function createUnnamedEntityResource<E extends Entity>(
-  resource:
-    | ResourceRef<TypedEntityResourceValue<E>>
-    | Resource<TypedEntityResourceValue<E>>,
+function createUnnamedEntityResourceRef<E extends Entity>(
+  resource: ResourceRef<TypedEntityResourceValue<E>>,
 ) {
   return signalStoreFeature(
     withResource(() => resource),
@@ -182,6 +191,38 @@ function createUnnamedEntityResource<E extends Entity>(
   );
 }
 
+function createUnnamedEntityResource<E extends Entity>(
+  resource: Resource<TypedEntityResourceValue<E>>,
+) {
+  return signalStoreFeature(
+    withResource(() => resource),
+    withProps((store) => {
+      const propsStore = store as {
+        value: Signal<TypedEntityResourceValue<E>>;
+        status: Signal<ResourceStatus>;
+        error: Signal<Error | undefined>;
+        isLoading: Signal<boolean>;
+        snapshot: Signal<ResourceSnapshot<TypedEntityResourceValue<E>>>;
+      };
+
+      const resourceValue = propsStore.value as Signal<EntityResourceValue>;
+      if (!isSignal(resourceValue)) {
+        throw new Error(`Resource's value signal does not exist`);
+      }
+
+      const { ids, entityMap } = createReadonlyEntityDerivations(resourceValue);
+
+      return {
+        ids,
+        entityMap,
+      };
+    }),
+    withComputed(({ ids, entityMap }) => ({
+      entities: createComputedEntities(ids, entityMap),
+    })),
+  );
+}
+
 /**
  * See {@link createUnnamedEntityResource} for why we cannot use the value of `resource` directly.
  */
@@ -190,23 +231,46 @@ function createNamedEntityResources<Dictionary extends EntityDictionary>(
 ) {
   const keys = Object.keys(dictionary);
 
-  const stateFactories = keys.map((name) => {
-    return (store: Record<string, unknown>) => {
-      const resourceValue = store[
-        `${name}Value`
-      ] as Signal<EntityResourceValue>;
-      if (!isSignal(resourceValue)) {
-        throw new Error(`Resource's value ${name}Value does not exist`);
-      }
+  const stateFactories = keys
+    .filter((name) => isResourceRef(dictionary[name]))
+    .map((name) => {
+      return (store: Record<string, unknown>) => {
+        const resourceValue = store[
+          `${name}Value`
+        ] as Signal<EntityResourceValue>;
+        if (!isSignal(resourceValue)) {
+          throw new Error(`Resource's value ${name}Value does not exist`);
+        }
 
-      const { ids, entityMap } = createEntityDerivations(resourceValue);
+        const { ids, entityMap } = createEntityDerivations(resourceValue);
 
-      return {
-        [`${name}EntityMap`]: entityMap,
-        [`${name}Ids`]: ids,
+        return {
+          [`${name}EntityMap`]: entityMap,
+          [`${name}Ids`]: ids,
+        };
       };
-    };
-  });
+    });
+
+  const propsFactories = keys
+    .filter((name) => !isResourceRef(dictionary[name]))
+    .map((name) => {
+      return (store: Record<string, unknown>) => {
+        const resourceValue = store[
+          `${name}Value`
+        ] as Signal<EntityResourceValue>;
+        if (!isSignal(resourceValue)) {
+          throw new Error(`Resource's value ${name}Value does not exist`);
+        }
+
+        const { ids, entityMap } =
+          createReadonlyEntityDerivations(resourceValue);
+
+        return {
+          [`${name}EntityMap`]: entityMap,
+          [`${name}Ids`]: ids,
+        };
+      };
+    });
 
   const computedFactories = keys.map((name) => {
     return (store: Record<string, unknown>) => {
@@ -234,13 +298,28 @@ function createNamedEntityResources<Dictionary extends EntityDictionary>(
     withResource(() => dictionary),
     withLinkedState((store) =>
       stateFactories.reduce(
-        (acc, factory) => ({ ...acc, ...factory(store) }),
+        (acc, factory) => ({
+          ...acc,
+          ...factory(store),
+        }),
+        {},
+      ),
+    ),
+    withProps((store) =>
+      propsFactories.reduce(
+        (acc, factory) => ({
+          ...acc,
+          ...factory(store),
+        }),
         {},
       ),
     ),
     withComputed((store) =>
       computedFactories.reduce(
-        (acc, factory) => ({ ...acc, ...factory(store) }),
+        (acc, factory) => ({
+          ...acc,
+          ...factory(store),
+        }),
         {},
       ),
     ),
@@ -268,12 +347,37 @@ function createNamedEntityResources<Dictionary extends EntityDictionary>(
  * - For named resources we return `NamedResourceResult<T>` intersected with
  *   `NamedEntityState<E, Name>` and `NamedEntityProps<E, Name>` for each entry.
  */
-export type EntityResourceResult<Entity> = {
+declare const NON_PATCHABLE_ENTITY_RESOURCE_STATE: unique symbol;
+
+type NonPatchableEntityResourceStateMarker = {
+  [NON_PATCHABLE_ENTITY_RESOURCE_STATE]?: never;
+};
+
+type ReadonlyEntityProps<E extends Entity> = {
+  ids: Signal<EntityId[]>;
+  entityMap: Signal<Record<EntityId, E>>;
+};
+
+type NamedReadonlyEntityProps<E extends Entity, Name extends string> = {
+  [Prop in `${Name}Ids`]: Signal<EntityId[]>;
+} & {
+  [Prop in `${Name}EntityMap`]: Signal<Record<EntityId, E>>;
+};
+
+export type EntityResourceRefResult<Entity> = {
   state: ResourceResult<Entity>['state'] & EntityState<Entity>;
   props: ResourceResult<Entity>['props'] & EntityProps<Entity>;
   methods: ResourceResult<Entity>['methods'];
 };
 
+export type EntityResourceResult<Entity extends { id: EntityId }> = {
+  state: NonPatchableEntityResourceStateMarker;
+  props: ResourceResult<Entity>['props'] &
+    EntityProps<Entity> &
+    ReadonlyEntityProps<Entity>;
+  methods: ResourceResult<Entity>['methods'];
+};
+
 // Generic helpers for inferring entity types and merging unions
 type ArrayElement<T> = T extends readonly (infer E)[] | (infer E)[] ? E : never;
 
@@ -300,15 +404,33 @@ export type EntityDictionary = Record<
 type MergeNamedEntityStates<T extends EntityDictionary> = MergeUnion<
   {
     [Prop in keyof T]: Prop extends string
-      ? InferEntityFromSignal<T[Prop]['value']> extends infer E
-        ? E extends never
-          ? never
-          : NamedEntityState<E, Prop>
+      ? T[Prop] extends ResourceRef<unknown>
+        ? InferEntityFromSignal<T[Prop]['value']> extends infer E
+          ? E extends never
+            ? never
+            : NamedEntityState<E, Prop>
+          : never
         : never
       : never;
   }[keyof T]
 >;
 
+type MergeNamedReadonlyEntityProps<T extends EntityDictionary> = MergeUnion<
+  {
+    [Prop in keyof T]: Prop extends string
+      ? T[Prop] extends ResourceRef<unknown>
+        ? never
+        : InferEntityFromSignal<T[Prop]['value']> extends infer E
+          ? E extends Entity
+            ? NamedReadonlyEntityProps<E, Prop>
+            : E extends never
+              ? never
+              : never
+          : never
+      : never;
+  }[keyof T]
+>;
+
 type MergeNamedEntityProps<T extends EntityDictionary> = MergeUnion<
   {
     [Prop in keyof T]: Prop extends string
@@ -322,8 +444,12 @@ type MergeNamedEntityProps<T extends EntityDictionary> = MergeUnion<
 >;
 
 export type NamedEntityResourceResult<T extends EntityDictionary> = {
-  state: NamedResourceResult<T, false>['state'] & MergeNamedEntityStates<T>;
-  props: NamedResourceResult<T, false>['props'] & MergeNamedEntityProps<T>;
+  state: NamedResourceResult<T, false>['state'] &
+    MergeNamedEntityStates<T> &
+    NonPatchableEntityResourceStateMarker;
+  props: NamedResourceResult<T, false>['props'] &
+    MergeNamedEntityProps<T> &
+    MergeNamedReadonlyEntityProps<T>;
   methods: NamedResourceResult<T, false>['methods'];
 };
 
@@ -374,6 +500,22 @@ function createEntityDerivations<E extends Entity>(
   return { ids, entityMap };
 }
 
+function createReadonlyEntityDerivations<E extends Entity>(
+  source: Signal<TypedEntityResourceValue<E>>,
+) {
+  const ids = computed(() => (source() ?? []).map((e) => e.id));
+
+  const entityMap = computed(() => {
+    const map = {} as Record<EntityId, E>;
+    for (const item of source() ?? []) {
+      map[item.id] = item as E;
+    }
+    return map;
+  });
+
+  return { ids, entityMap };
+}
+
 function createComputedEntities<E extends Entity>(
   ids: Signal<EntityId[]>,
   entityMap: Signal<Record<EntityId, E>>,