Adopt for Effector 23 (#401)

* Adopt for Effector 23 * Use EventCallable for commands * Format * Add migration info * Migrate some deprecations * Migrate some deprecations * Migrate some deprecations * Migrate some deprecations * Migrate some deprecations * Migrate some deprecations * Migrate some deprecations * Adopt for Effector 23 * Fix all warnings * Use stable effector * Use stable effector * Adopt Barrier API to effector 23 * Adopt Barrier API to effector 23 * format
igorkamyshev · Nov 29, 2023 · ffdfffa · ffdfffa
1 parent ec2ab95
commit ffdfffa
Show file tree

Hide file tree

Showing 37 changed files with 277 additions and 141 deletions.
diff --git a/.changeset/unlucky-weeks-talk.md b/.changeset/unlucky-weeks-talk.md
@@ -0,0 +1,6 @@
+---
+'@farfetched/core': minor
+'@farfetched/solid': minor
+---
+
+Adopt for Effector 23
diff --git a/.changeset/witty-gifts-visit.md b/.changeset/witty-gifts-visit.md
@@ -0,0 +1,5 @@
+---
+'@farfetched/atomic-router': minor
+---
+
+Adopt for Effector 23
diff --git a/apps/website/docs/releases/0-11.md b/apps/website/docs/releases/0-11.md
@@ -1,7 +1,13 @@
 # v0.11
 
+This release contains a couple of breaking changes, so please read the migration guide carefully.
+
 ## Migration guide
 
+### Use Effector v23
+
+To use Farfetched v0.11 you need to use Effector v23 and have all related dependencies (`effector-solid`, `effector-vue`, etc.) updated. Please, refer to Effector v23 migration guide for more details.
+
 ### Delete `isAbortError`
 
 Since [v0.10](/releases/0-10) aborted [_Queries_](/api/primitives/query) and [_Mutations_](/api/primitives/mutation) are not treated as failed anymore. So, `isAbortError` is not needed can be safely removed from your codebase.

diff --git a/package.json b/package.json
@@ -42,7 +42,7 @@
     "@vitejs/plugin-react": "3",
     "@vitest/ui": "^0.25.8",
     "bytes-iec": "^3.1.1",
-    "effector": "^22.5.0",
+    "effector": "23.0.0",
     "eslint": "~8.15.0",
     "fp-ts": "^2.13.1",
     "glob": "^8.0.3",
@@ -71,8 +71,8 @@
   "dependencies": {
     "atomic-router": "0.6",
     "atomic-router-solid": "0.5",
-    "effector-react": "^22.3.0",
-    "effector-solid": "0.22.7",
+    "effector-react": "23.0.0",
+    "effector-solid": "0.23.0",
     "forest": "^0.21.2",
     "history": "^5.3.0",
     "mermaid": "9.1.7",

diff --git a/packages/atomic-router/src/chain.ptorocol.ts b/packages/atomic-router/src/chain.ptorocol.ts
@@ -1,8 +1,8 @@
-import { type EventAsReturnType } from 'effector';
-import { type RouteParamsAndQuery } from 'atomic-router';
+import type { Event, EventCallable } from 'effector';
+import type { RouteParamsAndQuery } from 'atomic-router';
 
 export type ChainProtocol<RouteParams extends Record<string, any>> = {
-  beforeOpen: EventAsReturnType<RouteParamsAndQuery<RouteParams>>;
-  openOn: EventAsReturnType<any>;
-  cancelOn: EventAsReturnType<any>;
+  beforeOpen: EventCallable<RouteParamsAndQuery<RouteParams>>;
+  openOn: Event<any>;
+  cancelOn: Event<any>;
 };
diff --git a/packages/core/package.json b/packages/core/package.json
@@ -3,6 +3,6 @@
   "version": "0.10.6",
   "type": "commonjs",
   "peerDependencies": {
-    "effector": "^22.5.0"
+    "effector": "^23.0.0"
   }
 }
diff --git a/packages/core/src/attach/attach.ts b/packages/core/src/attach/attach.ts
@@ -81,7 +81,11 @@ export function attachOperation<
   const { source, mapParams } = config ?? {};
 
   return operation.__.experimentalAPI?.attach({
-    source: source ?? createStore(null, { serialize: 'ignore' }),
+    source:
+      source ??
+      createStore(null, {
+        serialize: 'ignore',
+      }),
     mapParams: mapParams ?? ((v: NewParams) => v as unknown as OriginalParams),
   });
 }
diff --git a/packages/core/src/barrier_api/__tests__/create_barrier.test-d.ts b/packages/core/src/barrier_api/__tests__/create_barrier.test-d.ts
@@ -1,5 +1,10 @@
 import { describe, expectTypeOf, test } from 'vitest';
-import { createStore, type Effect, type Event } from 'effector';
+import {
+  createStore,
+  type EventCallable,
+  type Effect,
+  type Event,
+} from 'effector';
 
 import { type Query } from '../../query/type';
 import { type Mutation } from '../../mutation/type';
@@ -65,7 +70,7 @@ describe('createBarrier', () => {
     });
 
     test('accept start/end Events as performer', () => {
-      const voidEvent: Event<void> = {} as any;
+      const voidEvent: EventCallable<void> = {} as any;
       const paramsEvent: Event<{ id: number }> = {} as any;
 
       // void Event as start is allowed

diff --git a/packages/core/src/barrier_api/create_barrier.ts b/packages/core/src/barrier_api/create_barrier.ts
@@ -5,6 +5,7 @@ import {
   is,
   sample,
   split,
+  type EventCallable,
   type Effect,
   type Event,
   type Store,
@@ -20,10 +21,10 @@ import { get, Mutex } from '../libs/lohyphen';
 type Performer =
   | RemoteOperation<void, any, any, any>
   | Effect<void, any, any>
-  | { start: Event<void>; end: Event<any> };
+  | { start: EventCallable<void>; end: Event<any> };
 
 type NormalizedPerformer = {
-  start: Event<void> | Effect<void, any, any>;
+  start: EventCallable<void> | Effect<void, any, any>;
   end: Event<void>;
   $pending: Store<boolean>;
 };
@@ -121,7 +122,7 @@ export function createBarrier({
 
   const performers = normalizePerformers(perform ?? []);
 
-  let $active: Store<boolean>;
+  let $active;
   // Overload: active
   if (active) {
     $active = active;
@@ -185,7 +186,9 @@ export function createBarrier({
   };
 }
 
-function startOnlyNotPending(performers: NormalizedPerformer[]): Event<void> {
+function startOnlyNotPending(
+  performers: NormalizedPerformer[]
+): EventCallable<void> {
   const clock = createEvent();
 
   for (const { start, $pending } of performers) {

diff --git a/packages/core/src/barrier_api/type.ts b/packages/core/src/barrier_api/type.ts
@@ -1,6 +1,6 @@
-import { type Event, type Store } from 'effector';
+import type { EventCallable, Event, Store } from 'effector';
 
-import { Mutex } from '../libs/lohyphen/mutex';
+import type { Mutex } from '../libs/lohyphen/mutex';
 
 export type Barrier = {
   /**
@@ -22,15 +22,15 @@ export type Barrier = {
     /**
      * Call this event every time when operation with applied Barrier tries to start
      */
-    touch: Event<void>;
+    touch: EventCallable<void>;
     /**
      * Call this event every time when operation with applied Barrier fails
      */
-    operationFailed: Event<{ params: unknown; error: unknown }>;
+    operationFailed: EventCallable<{ params: unknown; error: unknown }>;
     /**
      * Call this event every time when operation with applied Barrier succeeds
      */
-    operationDone: Event<{ params: unknown; result: unknown }>;
+    operationDone: EventCallable<{ params: unknown; result: unknown }>;
     /**
      * Barrier ia based on Mutex, this store provides direct access to it
      */

diff --git a/packages/core/src/cache/adapters/browser_storage.ts b/packages/core/src/cache/adapters/browser_storage.ts
@@ -155,7 +155,11 @@ export function browserStorageCache(
   }
 
   // -- meta storage
-  const $meta = createStore<Meta | null>(null, { serialize: 'ignore' });
+  const $meta = createStore<Meta | null>(null, {
+    serialize: 'ignore',
+    name: 'ff.browserStorage.$meta',
+    sid: 'ff.browserStorage.$meta',
+  });
 
   const getMetaFx = createEffect(async () => {
     const meta = await getItemFx(META_KEY);

diff --git a/packages/core/src/cache/adapters/instance.ts b/packages/core/src/cache/adapters/instance.ts
@@ -7,7 +7,8 @@ export function createCacheAdapter(
 ): CacheAdapter {
   const $instance = createStore(adapter, {
     serialize: 'ignore',
-    sid: 'ff.cache_instance',
+    name: 'ff.$cacheInstance',
+    sid: 'ff.$cacheInstance',
   });
 
   return { ...adapter, __: { $instance } };

diff --git a/packages/core/src/cache/adapters/observability.ts b/packages/core/src/cache/adapters/observability.ts
@@ -1,6 +1,6 @@
-import { Event, sample } from 'effector';
+import { type Event, sample } from 'effector';
 
-import { CacheAdapterInstance, CacheAdapterOptions } from './type';
+import type { CacheAdapterInstance, CacheAdapterOptions } from './type';
 
 export function attachObservability({
   adapter,

diff --git a/packages/core/src/cache/adapters/type.ts b/packages/core/src/cache/adapters/type.ts
@@ -1,22 +1,22 @@
-import { Effect, Event, Store } from 'effector';
+import type { Effect, Event, EventCallable, Store } from 'effector';
 
 import { Time } from '../../libs/date-nfs';
 
 export interface CacheAdapterInstance {
   get: Effect<{ key: string }, { value: unknown; cachedAt: number } | null>;
   set: Effect<{ key: string; value: unknown }, void>;
-  purge: Event<void>;
+  purge: EventCallable<void>;
   unset: Effect<{ key: string }, void>;
 }
 
 export interface CacheAdapterOptions {
   maxEntries?: number;
   maxAge?: Time;
   observability?: {
-    hit?: Event<{ key: string }>;
-    miss?: Event<{ key: string }>;
-    expired?: Event<{ key: string }>;
-    evicted?: Event<{ key: string }>;
+    hit?: EventCallable<{ key: string }>;
+    miss?: EventCallable<{ key: string }>;
+    expired?: EventCallable<{ key: string }>;
+    evicted?: EventCallable<{ key: string }>;
   };
 }
 

diff --git a/packages/core/src/fetch/api.ts b/packages/core/src/fetch/api.ts
@@ -163,7 +163,11 @@ export function createApiRequest<
 
   const prepareFx = createEffect(config.response.extract);
 
-  const $haveToBeAborted = createStore(false, { serialize: 'ignore' });
+  const $haveToBeAborted = createStore(false, {
+    serialize: 'ignore',
+    name: 'ff.$haveToBeAborted',
+    sid: 'ff.$haveToBeAborted',
+  });
 
   const apiRequestFx = createEffect<
     DynamicRequestConfig<B> &

diff --git a/packages/core/src/libs/patronus/abortable.ts b/packages/core/src/libs/patronus/abortable.ts
@@ -77,7 +77,11 @@ export function abortable<P = void, D = void, F = Error>(config: {
 
     return result;
   });
-  const $calls = createStore<CurrentCall[]>([], { serialize: 'ignore' });
+  const $calls = createStore<CurrentCall[]>([], {
+    serialize: 'ignore',
+    name: 'ff.$calls',
+    sid: 'ff.$calls',
+  });
   const callsApi = createApi($calls, {
     add(calls, def: CurrentCall) {
       return [...calls, def];
@@ -88,14 +92,18 @@ export function abortable<P = void, D = void, F = Error>(config: {
   });
 
   if (abort?.signal) {
-    const abortTrigger = sample({ clock: abort.signal });
-
-    $calls.watch(abortTrigger, (calls) => {
+    const cancelAllFx = createEffect((calls: CurrentCall[]) => {
       calls.forEach((c) => {
         c.context?.runAborters?.();
         c.reject(abortError());
       });
     });
+
+    sample({
+      clock: abort.signal,
+      source: $calls,
+      target: cancelAllFx,
+    });
   }
 
   // нужно, чтобы поддержать и синхронные эффекты тоже

diff --git a/packages/core/src/libs/patronus/delay.ts b/packages/core/src/libs/patronus/delay.ts
@@ -2,10 +2,11 @@ import {
   createEffect,
   createEvent,
   sample,
-  Unit,
-  Event,
-  Store,
-  EventAsReturnType,
+  type Unit,
+  type Event,
+  type Store,
+  type EventAsReturnType,
+  type EventCallable,
 } from 'effector';
 
 import { normalizeStaticOrReactive } from './sourced';
@@ -17,7 +18,7 @@ export function delay<T>({
 }: {
   clock: Unit<T>;
   timeout: Store<number> | number;
-  target?: Event<T>;
+  target?: EventCallable<T>;
 }): EventAsReturnType<T> {
   const timerFx = createEffect<{ payload: T; milliseconds: number }, T>(
     ({ payload, milliseconds }) =>

diff --git a/packages/core/src/libs/patronus/postpone.ts b/packages/core/src/libs/patronus/postpone.ts
@@ -24,7 +24,11 @@ export function postpone<T>({
 }): EventAsReturnType<T> {
   const target = createEvent<T>();
 
-  const $fired = createStore(false, { serialize: 'ignore' })
+  const $fired = createStore(false, {
+    serialize: 'ignore',
+    name: 'ff.$fired',
+    sid: 'ff.$fired',
+  })
     .on(target, () => true)
     .on(clock, () => false);
 

diff --git a/packages/core/src/libs/patronus/readonly.ts b/packages/core/src/libs/patronus/readonly.ts
@@ -6,5 +6,5 @@ export function readonly<T>(event: Event<T>): Event<T>;
 export function readonly<T>(
   storeOrEvent: Store<T> | Event<T>
 ): Store<T> | Event<T> {
-  return storeOrEvent.map((v) => v);
+  return storeOrEvent.map((v) => v, { skipVoid: false });
 }
diff --git a/packages/core/src/libs/patronus/sourced.ts b/packages/core/src/libs/patronus/sourced.ts
@@ -45,7 +45,11 @@ function normalizeSourced<Data, Result, Source>({
 
   if (field === undefined) {
     // do nothing
-    $target = createStore((_: Data) => null as any, { serialize: 'ignore' });
+    $target = createStore((_: Data) => null as any, {
+      serialize: 'ignore',
+      name: 'ff.$target/undefined',
+      sid: 'ff.$target/undefined',
+    });
   } else if (is.store(field)) {
     const $storeField = field as Store<Result>;
 
@@ -71,13 +75,17 @@ function normalizeSourced<Data, Result, Source>({
       (params: Data): Result | null => callbackField(params) ?? null,
       {
         serialize: 'ignore',
+        name: 'ff.$target/callbackField',
+        sid: 'ff.$target/$callbackField',
       }
     );
   } else {
     const valueField = field as Result;
 
     $target = createStore((_: Data): Result | null => valueField ?? null, {
       serialize: 'ignore',
+      name: 'ff.$target/valueField',
+      sid: 'ff.$target/$valueField',
     });
   }
 
@@ -201,6 +209,8 @@ function normalizeStaticOrReactive<T>(
   if (!v) {
     return createStore<Exclude<T, undefined> | null>(null, {
       serialize: 'ignore',
+      name: 'ff.$target/undefined',
+      sid: 'ff.$target/$undefined',
     });
   }
 
@@ -210,14 +220,16 @@ function normalizeStaticOrReactive<T>(
 
   return createStore<Exclude<T, undefined> | null>(v as Exclude<T, undefined>, {
     serialize: 'ignore',
+    name: 'ff.$target/valueField',
+    sid: 'ff.$target/$valueField',
   });
 }
 
 // -- Extract source
 
 function extractSource<S>(sourced: SourcedField<any, any, S>): Store<S> | null {
   if (is.store(sourced)) {
-    return sourced;
+    return sourced as Store<S>;
   }
 
   if (sourced?.source) {