@fozy-labs/rx-toolkit 0.5.3-rc.1 → 0.5.3-rc.2

package/README.md

@@ -44,7 +44,7 @@ RxToolkit решает эти проблемы, предоставляя сво
 ###### Создаем сигнал
 ```typescript
 // Описываем логику в обычном JavaScript
-const count$ = Signal.create(0);
+const count$ = Signal.state(0);
 const doubled$ = Signal.compute(() => count$() * 2);
 const increment = () => count$.set(count$() + 1);
 ```
@@ -102,7 +102,7 @@ const getCart = createResource({
     queryFn: fetchCart,
 });
 
-const toggleCardItem = createOperation({
+const toggleCardItem = createCommand({
     queryFn: fetchToggleCardItem,
     link(add) {
         add({
@@ -119,7 +119,7 @@ const toggleCardItem = createOperation({
 
 function ShoppingCart() {
     const cartQuery = useResourceAgent(getCart);
-    const [toggleItem] = useOperationAgent(toggleCardItem);
+    const [toggleItem] = useCommandAgent(toggleCardItem);
     const cart = cartQuery.data;
 
     return (

package/dist/common/options/DefaultOptions.d.ts

@@ -1,4 +1,4 @@
-import type { DevtoolsLike } from "@/common/devtools";
+import type { DevtoolsLike } from "../../common/devtools";
 type Update = Partial<{
     DEVTOOLS: DevtoolsLike | null;
     onQueryError: (error: unknown) => void;

package/dist/common/options/SharedOptions.d.ts

@@ -1,5 +1,5 @@
-import { DevtoolsLike } from "@/common/devtools";
-import { shallowEqual } from "@/common/utils";
+import { DevtoolsLike } from "../../common/devtools";
+import { shallowEqual } from "../../common/utils";
 export declare class SharedOptions {
     static DEVTOOLS: DevtoolsLike | null;
     static onQueryError: ((error: unknown) => void) | null;

package/dist/query/api/createCommand.d.ts

@@ -0,0 +1,21 @@
+import type { CommandCreateOptions, CommandDefinition } from "../../query/types";
+import { Command } from "../../query/core/Command/Command";
+/**
+ * Создаёт команду (command) — единицу мутирующего запроса.
+ *
+ * Команда инкапсулирует асинхронную операцию с поддержкой кеширования,
+ * связывания с ресурсами (link) и оптимистичных обновлений.
+ *
+ * @example
+ * ```ts
+ * const updateUser = createCommand({
+ *   queryFn: (args: { id: string; name: string }) => api.updateUser(args),
+ *   link: (link) => link({
+ *     resource: userResource,
+ *     forwardArgs: (args) => ({ id: args.id }),
+ *     invalidate: true,
+ *   }),
+ * });
+ * ```
+ */
+export declare const createCommand: <ARGS, RESULT, SELECTED = never>(options: CommandCreateOptions<CommandDefinition<ARGS, RESULT, SELECTED>>) => Command<CommandDefinition<ARGS, RESULT, SELECTED>>;

package/dist/query/api/createCommand.js

@@ -0,0 +1,20 @@
+import { Command } from "../../query/core/Command/Command";
+/**
+ * Создаёт команду (command) — единицу мутирующего запроса.
+ *
+ * Команда инкапсулирует асинхронную операцию с поддержкой кеширования,
+ * связывания с ресурсами (link) и оптимистичных обновлений.
+ *
+ * @example
+ * ```ts
+ * const updateUser = createCommand({
+ *   queryFn: (args: { id: string; name: string }) => api.updateUser(args),
+ *   link: (link) => link({
+ *     resource: userResource,
+ *     forwardArgs: (args) => ({ id: args.id }),
+ *     invalidate: true,
+ *   }),
+ * });
+ * ```
+ */
+export const createCommand = ((options) => new Command(options));

package/dist/query/api/createOperation.d.ts

@@ -1,3 +1,5 @@
-import type { OperationCreateOptions, OperationDefinition } from "@/query/types";
-import { Operation } from "@/query/core/Opertation/Operation";
-export declare const createOperation: <ARGS, RESULT, SELECTED = never>(options: OperationCreateOptions<OperationDefinition<ARGS, RESULT, SELECTED>>) => Operation<OperationDefinition<ARGS, RESULT, SELECTED>>;
+/**
+ * @deprecated Use `createCommand` instead. Will be removed in v0.6.0.
+ * @see createCommand
+ */
+export declare const createOperation: <ARGS, RESULT, SELECTED = never>(options: import("../types").CommandCreateOptions<import("../types").CommandDefinition<ARGS, RESULT, SELECTED>>) => import("../core/Command").Command<import("../types").CommandDefinition<ARGS, RESULT, SELECTED>>;

package/dist/query/api/createOperation.js

@@ -1,2 +1,6 @@
-import { Operation } from "../../query/core/Opertation/Operation";
-export const createOperation = ((options) => new Operation(options));
+import { createCommand } from './createCommand';
+/**
+ * @deprecated Use `createCommand` instead. Will be removed in v0.6.0.
+ * @see createCommand
+ */
+export const createOperation = createCommand;

package/dist/query/api/createResource.d.ts

@@ -1,3 +1,3 @@
-import type { ResourceCreateOptions, ResourceDefinition } from "@/query/types";
-import { Resource } from "@/query/core/Resource/Resource";
+import type { ResourceCreateOptions, ResourceDefinition } from "../../query/types";
+import { Resource } from "../../query/core/Resource/Resource";
 export declare const createResource: <ARGS, RESULT, SELECTED = never>(options: ResourceCreateOptions<ResourceDefinition<ARGS, RESULT, SELECTED>>) => Resource<ResourceDefinition<ARGS, RESULT, SELECTED>>;

package/dist/query/api/createResourceDuplicator.d.ts

@@ -1,4 +1,4 @@
-import { DuplicatorOptions, ResourceDuplicator, DuplicatorDefinition } from "@/query/core/Resource/ResourceDuplicator";
-import { ResourceDefinition } from "@/query/types";
+import { DuplicatorOptions, ResourceDuplicator, DuplicatorDefinition } from "../../query/core/Resource/ResourceDuplicator";
+import { ResourceDefinition } from "../../query/types";
 export declare const createResourceDuplicator: <ARGS, RESULT, SELECTED = never>(options: DuplicatorOptions<DuplicatorDefinition<ResourceDefinition<ARGS, RESULT, SELECTED>>>) => ResourceDuplicator<DuplicatorDefinition<ResourceDefinition<ARGS, RESULT, SELECTED>>>;
 export type ResourceDuplicatorCreateFn<ARGS, RESULT, SELECTED = never> = (options: DuplicatorOptions<DuplicatorDefinition<ResourceDefinition<ARGS, RESULT, SELECTED>>>) => ResourceDuplicator<DuplicatorDefinition<ResourceDefinition<ARGS, RESULT, SELECTED>>>;

package/dist/query/core/Command/Command.d.ts

@@ -0,0 +1,35 @@
+import type { ReactiveCache } from "../../../query/lib/ReactiveCache";
+import type { FallbackOnNever, CommandCreateOptions, CommandDefinition, CommandInstance } from "../../../query/types";
+import { CommandAgent } from "./CommandAgent";
+export type CoreCommandQueryState<D extends CommandDefinition> = {
+    arg: D['Args'] | null;
+    data: FallbackOnNever<D['Selected'], D['Result']> | null;
+    error: unknown | null;
+    isError: boolean;
+    isLoading: boolean;
+    isRepeating: boolean;
+    isDone: boolean;
+    isSuccess: boolean;
+    isInitiated: boolean;
+};
+export declare class Command<D extends CommandDefinition> implements CommandInstance<D> {
+    private readonly _options;
+    private _queriesCache;
+    private _hooks;
+    private _links;
+    private _DEFAULT_CACHE_LIFETIME;
+    constructor(_options: CommandCreateOptions<D>);
+    private _createLinks;
+    createAgent(): CommandAgent<D>;
+    getQueryCache(args: D['Args']): ReactiveCache<CoreCommandQueryState<D>> | undefined;
+    createQueryCache(args: D['Args'], state?: CoreCommandQueryState<D>): ReactiveCache<CoreCommandQueryState<D>>;
+    initiate(args: D['Args'], options?: {
+        cache?: ReactiveCache<CoreCommandQueryState<D>>;
+    }): ReactiveCache<CoreCommandQueryState<D>>;
+    private _initiate;
+    /**
+     * Используется для обратной совместимости
+     * @deprecated
+     */
+    mutate(args: D['Args']): Promise<D['Data']>;
+}

package/dist/query/core/Command/Command.js

@@ -0,0 +1,210 @@
+import { PromiseResolver } from "../../../common/utils";
+import { Batcher } from "../../../signals";
+import { QueriesCache } from "../QueriesCache";
+import { QueriesLifetimeHooks } from "../QueriesLifetimeHooks";
+import { CommandAgent } from "./CommandAgent";
+import { ResetAllQueriesSignal } from "../../../query/core/ResetAllQueriesSignal";
+class CommandQueryState {
+    static create() {
+        return {
+            arg: null,
+            data: null,
+            error: null,
+            isError: false,
+            isRepeating: false,
+            isDone: false,
+            isSuccess: false,
+            isLoading: false,
+            isInitiated: false,
+        };
+    }
+    static load(state = CommandQueryState.create(), args) {
+        return {
+            ...state,
+            arg: args,
+            isLoading: true,
+            isRepeating: state.isDone,
+            isInitiated: true,
+        };
+    }
+    static success(state, data) {
+        return {
+            ...state,
+            data,
+            isLoading: false,
+            isRepeating: false,
+            isDone: true,
+            isSuccess: true,
+            isError: false,
+            error: null,
+        };
+    }
+    static error(state, error) {
+        return {
+            ...state,
+            isLoading: false,
+            isRepeating: false,
+            isDone: true,
+            isSuccess: false,
+            isError: true,
+            error,
+        };
+    }
+}
+export class Command {
+    _options;
+    _queriesCache;
+    _hooks;
+    _links = [];
+    _DEFAULT_CACHE_LIFETIME = 1_000;
+    constructor(_options) {
+        this._options = _options;
+        this._queriesCache = new QueriesCache(this._options.cacheLifetime ?? this._DEFAULT_CACHE_LIFETIME);
+        this._hooks = new QueriesLifetimeHooks({
+            onCacheEntryAdded: _options.onCacheEntryAdded,
+            onQueryStarted: _options.onQueryStarted,
+            devtoolsName: _options.devtoolsName,
+        });
+        this._createLinks();
+        ResetAllQueriesSignal.clean$.subscribe(() => {
+            const caches = Array.from(this._queriesCache.values());
+            caches.forEach((cache) => {
+                cache.next(CommandQueryState.create());
+            });
+        });
+    }
+    _createLinks() {
+        this._options.link?.((linkOptions) => {
+            this._links.push(linkOptions);
+        });
+    }
+    createAgent() {
+        return new CommandAgent(this);
+    }
+    getQueryCache(args) {
+        return this._queriesCache.getQueryCache(args);
+    }
+    createQueryCache(args, state = CommandQueryState.create()) {
+        const cache = this._queriesCache.createQueryCache(args, state);
+        const hookResolvers = this._hooks.onCacheEntryAdded(args);
+        const spySub = cache.spy$.subscribe((state) => {
+            if (!state.isDone)
+                return;
+            hookResolvers.cacheDataLoaded();
+            spySub.unsubscribe();
+        });
+        cache.spy$.subscribe((state) => {
+            hookResolvers.dataChanged$.next(state);
+        });
+        cache.onClean$.subscribe(() => {
+            hookResolvers.cacheEntryRemoved();
+        });
+        return cache;
+    }
+    initiate(args, options) {
+        return Batcher.run(() => this._initiate(args, options));
+    }
+    _initiate(args, options) {
+        let cache = options?.cache ?? this.getQueryCache(args);
+        const state = CommandQueryState.load(cache?.value, args);
+        if (!cache) {
+            cache = this.createQueryCache(args, state);
+        }
+        else {
+            cache.next(state);
+        }
+        const linksMeta = this._links.map(link => {
+            const forwardedArgs = link.forwardArgs(args);
+            const ref = link.resource.createRef(forwardedArgs);
+            return { link, ref, state: {} };
+        });
+        const query = this._options.queryFn(args);
+        const hookResolvers = this._hooks.onQueryStarted(args);
+        linksMeta.forEach(({ link, ref, state }) => {
+            if (link.lock) {
+                state.unlocker = ref.lock();
+            }
+            if (link.optimisticUpdate && ref.has) {
+                state.patch = ref.patch((draft) => {
+                    return link.optimisticUpdate({ draft, args });
+                });
+            }
+        });
+        query
+            .then((result) => {
+            Batcher.run(() => {
+                const data = this._options.select ? this._options.select(result) : result;
+                cache.next(CommandQueryState.success(state, data));
+                /**
+                 * Обновляем связанные ресурсы
+                 */
+                linksMeta.forEach(({ link, ref, state }) => {
+                    if (link.update && ref.has) {
+                        ref.patch((draft) => {
+                            return link.update({ draft, args, data });
+                        })?.commit();
+                    }
+                    if (link.create && !ref.has) {
+                        ref.create(link.create({ args, data }));
+                    }
+                    if (link.invalidate) {
+                        ref.invalidate();
+                    }
+                    state.patch?.commit();
+                });
+                hookResolvers.fulfilledSuccess(data);
+                /**
+                 * Обновляем связанные ресурсы
+                 */
+                linksMeta.forEach(({ state }) => {
+                    state.unlocker?.unlock();
+                });
+            });
+        })
+            .catch((error) => {
+            Batcher.run(() => {
+                cache.next(CommandQueryState.error(state, error));
+                /**
+                 * Обновляем связанные ресурсы
+                 */
+                linksMeta.forEach(({ state }) => {
+                    state.patch?.abort();
+                });
+                hookResolvers.fulfilledError(error);
+                /**
+                 * Обновляем связанные ресурсы
+                 */
+                linksMeta.forEach(({ state }) => {
+                    state.unlocker?.unlock();
+                });
+            });
+        });
+        return cache;
+    }
+    /**
+     * Используется для обратной совместимости
+     * @deprecated
+     */
+    mutate(args) {
+        const cache = this.initiate(args);
+        const resolver = new PromiseResolver();
+        const subscription = cache.value$.obs.subscribe((state) => {
+            if (!state.isInitiated || state.isLoading || state.isRepeating)
+                return;
+            if (state.isError) {
+                resolver.reject(state.error);
+                return;
+            }
+            if (!state.isSuccess) {
+                console.error("Unexpected state in mutation:", state);
+                resolver.reject(new Error("Unexpected state in mutation"));
+                return;
+            }
+            resolver.resolve(state.data);
+        });
+        resolver.promise.finally(() => {
+            subscription.unsubscribe();
+        });
+        return resolver.promise;
+    }
+}

package/dist/query/core/Command/CommandAgent.d.ts

@@ -0,0 +1,19 @@
+import type { CommandAgentInstance, CommandDefinition } from "../../../query/types";
+import type { Command } from "./Command";
+export declare class CommandAgent<D extends CommandDefinition> implements CommandAgentInstance<D> {
+    private _command;
+    private _commands$;
+    state$: import("../../../signals/types").ComputeFn<{
+        isLoading: boolean;
+        isDone: boolean;
+        isSuccess: boolean;
+        isError: boolean;
+        error: {} | undefined;
+        data: NonNullable<import("../../../query/types").FallbackOnNever<D["Selected"], D["Result"]>> | undefined;
+        args: D["Args"];
+    }>;
+    constructor(_command: Command<D>);
+    private _next;
+    initiate(args: D["Args"]): void;
+    createAgent(): CommandAgentInstance<D>;
+}

package/dist/query/core/Command/CommandAgent.js

@@ -0,0 +1,54 @@
+import { Computed, Signal } from "../../../signals";
+export class CommandAgent {
+    _command;
+    _commands$ = Signal.state({
+        current$: null,
+    }, { isDisabled: true });
+    state$ = Computed.create(() => {
+        const commands = this._commands$.get();
+        const currState = commands.current$?.value$.get();
+        // Нет текущего состояния — дефолт
+        if (!currState) {
+            return {
+                isLoading: false,
+                isDone: false,
+                isSuccess: false,
+                isError: false,
+                error: undefined,
+                data: undefined,
+                args: undefined,
+            };
+        }
+        return {
+            isLoading: currState.isLoading,
+            isDone: currState.isDone,
+            isSuccess: currState.isSuccess,
+            isError: currState.isError,
+            error: currState.error ?? undefined,
+            data: currState.data ?? undefined,
+            args: currState.arg,
+        };
+    }, { isDisabled: true });
+    constructor(_command) {
+        this._command = _command;
+    }
+    _next(newCache) {
+        this._commands$.set({
+            current$: newCache,
+        });
+    }
+    initiate(args) {
+        const cache = this._command.getQueryCache(args);
+        if (!cache) {
+            const newCache = this._command.initiate(args);
+            this._next(newCache);
+            return;
+        }
+        // Всегда запускаем команду заново, так как команды обычно не кэшируются как ресурсы
+        const newCache = this._command.initiate(args, { cache });
+        this._next(newCache);
+    }
+    createAgent() {
+        return new CommandAgent(this._command);
+    }
+}

package/dist/query/core/Command/index.d.ts

@@ -0,0 +1,2 @@
+export { Command } from './Command';
+export { CommandAgent } from './CommandAgent';

package/dist/query/core/Command/index.js

@@ -0,0 +1,2 @@
+export { Command } from './Command';
+export { CommandAgent } from './CommandAgent';

package/dist/query/core/Opertation/Operation.d.ts

@@ -1,35 +1,8 @@
-import type { ReactiveCache } from "@/query/lib/ReactiveCache";
-import type { FallbackOnNever, OperationCreateOptions, OperationDefinition, OperationInstance } from "@/query/types";
-import { OperationAgent } from "./OperationAgent";
-export type CoreOperationQueryState<D extends OperationDefinition> = {
-    arg: D['Args'] | null;
-    data: FallbackOnNever<D['Selected'], D['Result']> | null;
-    error: unknown | null;
-    isError: boolean;
-    isLoading: boolean;
-    isRepeating: boolean;
-    isDone: boolean;
-    isSuccess: boolean;
-    isInitiated: boolean;
-};
-export declare class Operation<D extends OperationDefinition> implements OperationInstance<D> {
-    private readonly _options;
-    private _queriesCache;
-    private _hooks;
-    private _links;
-    private _DEFAULT_CACHE_LIFETIME;
-    constructor(_options: OperationCreateOptions<D>);
-    private _createLinks;
-    createAgent(): OperationAgent<D>;
-    getQueryCache(args: D['Args']): ReactiveCache<CoreOperationQueryState<D>> | undefined;
-    createQueryCache(args: D['Args'], state?: CoreOperationQueryState<D>): ReactiveCache<CoreOperationQueryState<D>>;
-    initiate(args: D['Args'], options?: {
-        cache?: ReactiveCache<CoreOperationQueryState<D>>;
-    }): ReactiveCache<CoreOperationQueryState<D>>;
-    private _initiate;
-    /**
-     * Используеются для обртной совместимости, а надо ли менять что-то - хз
-     * @deprecated
-     */
-    mutate(args: D['Args']): Promise<D['Data']>;
-}
+/**
+ * @deprecated Use `Command` from '../Command/Command' instead. Will be removed in v0.6.0.
+ */
+export { Command as Operation } from '../Command/Command';
+/**
+ * @deprecated Use `CoreCommandQueryState` from '../Command/Command' instead. Will be removed in v0.6.0.
+ */
+export type { CoreCommandQueryState as CoreOperationQueryState } from '../Command/Command';