Add editField api for easier fields edit

Author: zerobias

packages/core/src/__tests__/keyval/editField.test.ts

@@ -0,0 +1,92 @@
+import { expect, test } from 'vitest';
+import { createStore, combine } from 'effector';
+import { keyval } from '@effector/model';
+
+test('provide event for field update', () => {
+  const entities = keyval(() => {
+    const $id = createStore('');
+    const $count = createStore(0);
+    return {
+      key: 'id',
+      state: {
+        id: $id,
+        count: $count,
+      },
+      optional: ['count'],
+    };
+  });
+  entities.edit.add({ id: 'foo' });
+  entities.editField.count({ key: 'foo', data: 1 });
+  expect(entities.$items.getState()).toEqual([{ id: 'foo', count: 1 }]);
+});
+
+test('provide event for update multiple items at once', () => {
+  const entities = keyval(() => {
+    const $id = createStore('');
+    const $count = createStore(0);
+    return {
+      key: 'id',
+      state: {
+        id: $id,
+        count: $count,
+      },
+      optional: ['count'],
+    };
+  });
+  entities.edit.add([{ id: 'foo' }, { id: 'bar' }]);
+  entities.editField.count({ key: ['foo', 'bar'], data: [1, 2] });
+  expect(entities.$items.getState()).toEqual([
+    { id: 'foo', count: 1 },
+    { id: 'bar', count: 2 },
+  ]);
+});
+
+test('derived stores are omitted', () => {
+  const entities = keyval(() => {
+    const $id = createStore('');
+    return {
+      key: 'id',
+      state: {
+        id: $id,
+        idSize: combine($id, (id) => id.length),
+      },
+    };
+  });
+  //@ts-expect-error
+  expect(entities.editField.idSize).toBe(undefined);
+});
+
+test.skip('inner keyval support', () => {
+  const entities = keyval(() => {
+    const $id = createStore('');
+    const childs = keyval(() => {
+      const $id = createStore('');
+      const $count = createStore(0);
+      return {
+        key: 'id',
+        state: {
+          id: $id,
+          count: $count,
+        },
+      };
+    });
+    return {
+      key: 'id',
+      state: {
+        id: $id,
+        childs,
+      },
+    };
+  });
+  entities.edit.add({
+    id: 'foo',
+    childs: [
+      { id: 'childA', count: 0 },
+      { id: 'childB', count: 1 },
+    ],
+  });
+  entities.editField.childs({ key: 'foo', data: [{ id: 'childC', count: 2 }] });
+  expect(entities.$items.getState()).toEqual([
+    { id: 'foo', childs: [{ id: 'childC', count: 2 }] },
+  ]);
+});

packages/core/src/keyval.ts

@@ -23,6 +23,7 @@ import type {
   StructShape,
   OneOfShapeDef,
   EntityShapeDef,
+  KeyOrKeys,
 } from './types';
 import { spawn } from './spawn';
 import { model } from './model';
@@ -531,7 +532,7 @@ export function keyval<Input, ModelEnhance, Api, Shape>(
   const api = {} as Record<string, EventCallable<any>>;
 
   let structShape: any = null;
-
+  const editField = {} as any;
   if (kvModel) {
     // @ts-expect-error type issues
     const instance = spawn(kvModel, {});
@@ -575,6 +576,42 @@ export function keyval<Input, ModelEnhance, Api, Shape>(
         return state;
       });
     }
+    //TODO add support for generated keys
+    if (keyField) {
+      const structShape = kvModel.__struct!.shape;
+      for (const field in structShape) {
+        const fieldStruct = structShape[field];
+        if (fieldStruct.type === 'structUnit') {
+          // derived stores are not supported
+          if (fieldStruct.unit === 'store' && fieldStruct.derived) {
+            continue;
+          }
+          const fieldEditor = updateSome.prepend(
+            (upd: { key: KeyOrKeys; data: any }) => {
+              const keySet = Array.isArray(upd.key) ? upd.key : [upd.key];
+              const dataSet: Array<any> = Array.isArray(upd.key)
+                ? upd.data
+                : [upd.data];
+              const results = [] as Partial<Input>[];
+              for (let i = 0; i < keySet.length; i++) {
+                const keyValue = keySet[i];
+                const dataValue = dataSet[i];
+                const item = {} as Partial<Input>;
+                //@ts-expect-error
+                item[keyField] = keyValue;
+                //@ts-expect-error
+                item[field] = dataValue;
+                results.push(item);
+              }
+              return results;
+            },
+          );
+          editField[field] = fieldEditor;
+        } else {
+          // TODO keyval support
+        }
+      }
+    }
   } else if (shape!) {
     const itemStructShape: StructKeyval['shape'] = {};
     structShape = {
@@ -612,6 +649,7 @@ export function keyval<Input, ModelEnhance, Api, Shape>(
       remove: removeMany,
       map,
     },
+    editField,
   };
 }
 

packages/core/src/model.ts

@@ -126,6 +126,7 @@ export function model<
       : {
           type: 'structUnit',
           unit: 'store',
+          derived: !is.targetable(state[key] as any),
         };
     defaultState[key] = is.store(state[key]) ? state[key].getState() : [];
   }

packages/core/src/types.ts

@@ -136,10 +136,16 @@ export type LensEvent<T> = {
 };
 
 /** internal representation of model structure, unit leaf */
-export type StructUnit = {
-  type: 'structUnit';
-  unit: 'store' | 'event' | 'effect';
-};
+export type StructUnit =
+  | {
+      type: 'structUnit';
+      unit: 'event' | 'effect';
+    }
+  | {
+      type: 'structUnit';
+      unit: 'store';
+      derived: boolean;
+    };
 
 /** internal representation of model structure, model shape */
 export type StructShape = {
@@ -213,6 +219,15 @@ export type Keyval<Input, Enriched, Api, Shape> = {
       upsert?: boolean;
     }>;
   };
+  editField: {
+    [K in keyof Input]-?: EventCallable<
+      | { key: string | number; data: Exclude<Input[K], undefined> }
+      | {
+          key: Array<string | number>;
+          data: Exclude<Input[K], undefined>[];
+        }
+    >;
+  };
   // private
   __lens: Shape;
   // private