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

package/dist/query/core/Resource/ResourceDuplicator.js

@@ -1,5 +1,5 @@
-import { Signal, signalize } from "@/signals";
 import { finalize, ReplaySubject, share, Subject, takeUntil, timer } from "rxjs";
+import { Signal, signalize } from "../../../signals";
 import { ResourceDuplicatorAgent } from "./ResourceDuplicatorAgent";
 export class ResourceDuplicator {
     _options;
@@ -25,7 +25,7 @@ export class ResourceDuplicator {
             obs: value$.obs,
         });
         cache.onClean$.subscribe(() => {
-            args.forEach(arg => {
+            args.forEach((arg) => {
                 const argKey = this._options.getArgKey(arg);
                 const fi = this._fis.get(argKey);
                 if (!fi)
@@ -47,9 +47,9 @@ export class ResourceDuplicator {
             this._resource.initiate(unreleasedArgs);
         }
         const uninitiatedCaches = new Set();
-        args.forEach(arg => {
+        args.forEach((arg) => {
             const argKey = this._options.getArgKey(arg);
-            let fi = this._fis.get(argKey);
+            const fi = this._fis.get(argKey);
             if (fi && !fi.cache.value.isInitiated) {
                 uninitiatedCaches.add(fi.cache);
             }
@@ -61,9 +61,9 @@ export class ResourceDuplicator {
     }
     serialize(args) {
         if (!args)
-            return '';
-        const argsKeys = args.map(a => this._options.getArgKey(a));
-        return argsKeys.join('|');
+            return "";
+        const argsKeys = args.map((a) => this._options.getArgKey(a));
+        return argsKeys.join("|");
     }
     compareArgs(a, b) {
         return this.serialize(a) === this.serialize(b);
@@ -73,12 +73,12 @@ export class ResourceDuplicator {
     };
     /** @deprecated */
     d_init(args) {
-        const argsKeys = args.map(a => this._options.getArgKey(a));
+        const argsKeys = args.map((a) => this._options.getArgKey(a));
         const releasedCaches = new Set();
         const unreleasedArgs = [];
-        args.forEach(arg => {
+        args.forEach((arg) => {
             const argKey = this._options.getArgKey(arg);
-            let fi = this._fis.get(argKey);
+            const fi = this._fis.get(argKey);
             if (!fi || !fi.cache.value.isInitiated) {
                 unreleasedArgs.push(arg);
                 return;
@@ -86,10 +86,8 @@ export class ResourceDuplicator {
             fi.k++;
             releasedCaches.add(fi.cache);
         });
-        const queryCache = unreleasedArgs?.length > 0
-            ? this._resource.createQueryCache(unreleasedArgs)
-            : null;
-        unreleasedArgs.forEach(arg => {
+        const queryCache = unreleasedArgs?.length > 0 ? this._resource.createQueryCache(unreleasedArgs) : null;
+        unreleasedArgs.forEach((arg) => {
             const argKey = this._options.getArgKey(arg);
             let fi = this._fis.get(argKey);
             if (!fi) {
@@ -109,7 +107,7 @@ export class ResourceDuplicator {
                 for (const rc of releasedCaches) {
                     itemsAcc.push(rc.value$.get());
                 }
-                const isNotInitiated = itemsAcc.some(i => !i.isInitiated);
+                const isNotInitiated = itemsAcc.some((i) => !i.isInitiated);
                 const baseReturn = {
                     transactions: null,
                     abortController: null,
@@ -132,9 +130,9 @@ export class ResourceDuplicator {
                         ...baseReturn,
                         isInitiated: false,
                     };
-                const isError = itemsAcc.some(i => i.isError);
+                const isError = itemsAcc.some((i) => i.isError);
                 if (isError) {
-                    const firstError = itemsAcc.find(i => i.isError);
+                    const firstError = itemsAcc.find((i) => i.isError);
                     return {
                         ...baseReturn,
                         isError: true,
@@ -142,17 +140,17 @@ export class ResourceDuplicator {
                         error: firstError.error,
                     };
                 }
-                const isLoading = itemsAcc.some(i => i.isLoading);
+                const isLoading = itemsAcc.some((i) => i.isLoading);
                 if (isLoading)
                     return {
                         ...baseReturn,
                         isLoading: true,
                     };
                 const dataAcc = [];
-                itemsAcc.forEach(item => {
+                itemsAcc.forEach((item) => {
                     item.data?.forEach((d) => {
                         const dataKey = this._options.getDataKey(d);
-                        const index = argsKeys.findIndex(ak => ak === dataKey);
+                        const index = argsKeys.findIndex((ak) => ak === dataKey);
                         if (index === -1)
                             return;
                         dataAcc[index] = d;

package/dist/query/core/Resource/ResourceDuplicatorAgent.d.ts

@@ -1,9 +1,9 @@
-import { ResourceAgentInstance } from "@/query/types";
-import { ResourceDuplicator, DuplicatorDefinition } from "@/query/core/Resource/ResourceDuplicator";
-export declare class ResourceDuplicatorAgent<D extends DuplicatorDefinition> implements ResourceAgentInstance<D['RESOURCE_DEFINITION']> {
+import { DuplicatorDefinition, ResourceDuplicator } from "../../../query/core/Resource/ResourceDuplicator";
+import { ResourceAgentInstance } from "../../../query/types";
+export declare class ResourceDuplicatorAgent<D extends DuplicatorDefinition> implements ResourceAgentInstance<D["RESOURCE_DEFINITION"]> {
     private _resource;
     private _resources$;
-    state$: import("../../../signals/types").ComputeFn<{
+    state$: import("../../../signals").ComputeFn<{
         isInitiated: boolean;
         isLoading: boolean;
         isInitialLoading: boolean;
@@ -29,7 +29,7 @@ export declare class ResourceDuplicatorAgent<D extends DuplicatorDefinition> imp
         args: NonNullable<D["RESOURCE_DEFINITION"]["Args"]> | undefined;
     }>;
     constructor(_resource: ResourceDuplicator<D>);
-    initiate(args: D['ARGS_ITEM'][], force?: boolean): void;
-    compareArgs(args: D['ARGS_ITEM'][], otherArgs: D['ARGS_ITEM'][]): boolean;
+    initiate(args: D["ARGS_ITEM"][], force?: boolean): void;
+    compareArgs(args: D["ARGS_ITEM"][], otherArgs: D["ARGS_ITEM"][]): boolean;
     private _next;
 }

package/dist/query/core/Resource/ResourceDuplicatorAgent.js

@@ -1,7 +1,7 @@
 import { Computed, Signal } from "../../../signals";
 export class ResourceDuplicatorAgent {
     _resource;
-    _resources$ = Signal.create({
+    _resources$ = Signal.state({
         previous$: null,
         current$: null,
     }, { isDisabled: true });
@@ -60,8 +60,8 @@ export class ResourceDuplicatorAgent {
             isError: currState.isError,
             isLocked: currState.isLocked,
             isReloading: currState.isReloading,
-            error: isShowPrev ? prevState.error ?? undefined : currState.error ?? undefined,
-            data: isShowPrev ? prevState.data ?? undefined : currState.data ?? undefined,
+            error: isShowPrev ? (prevState.error ?? undefined) : (currState.error ?? undefined),
+            data: isShowPrev ? (prevState.data ?? undefined) : (currState.data ?? undefined),
             args: currState.args ?? undefined,
         };
     }, { isDisabled: true });

package/dist/query/core/Resource/ResourceRef.d.ts

@@ -1,6 +1,6 @@
-import { ResourceDefinition, ResourceRefInstanse, ResourceTransaction } from "@/query/types";
+import { ResourceDefinition, ResourceRefInstance, ResourceTransaction } from "../../../query/types";
 import { Resource } from "./Resource";
-export declare class ResourceRef<D extends ResourceDefinition> implements ResourceRefInstanse<D> {
+export declare class ResourceRef<D extends ResourceDefinition> implements ResourceRefInstance<D> {
     private readonly _resource;
     private readonly _args;
     private _cacheItem;

package/dist/query/core/Resource/ResourceRef.js

@@ -23,7 +23,7 @@ export class ResourceRef {
                     return;
                 isLocked = false;
                 this._resource.decrementLock(this._args, { cache: this._cacheItem });
-            }
+            },
         };
     }
     unlockOne() {
@@ -46,9 +46,9 @@ export class ResourceRef {
             let currentData = savedData ?? data;
             const remainingTransactions = [];
             let foundPending = false;
-            const lastPendingIndex = transactions.findLastIndex(t => t.status === 'pending');
+            const lastPendingIndex = transactions.findLastIndex((t) => t.status === "pending");
             transactions.forEach((transaction, index) => {
-                if (transaction.status === 'pending') {
+                if (transaction.status === "pending") {
                     foundPending = true;
                     // Применяем pending транзакцию и оставляем в очереди
                     currentData = applyPatches(currentData, transaction.patches);
@@ -56,12 +56,12 @@ export class ResourceRef {
                 }
                 else if (foundPending) {
                     // После pending транзакции
-                    if (transaction.status === 'committed') {
+                    if (transaction.status === "committed") {
                         // Применяем и оставляем в очереди
                         currentData = applyPatches(currentData, transaction.patches);
                         remainingTransactions.push(transaction);
                     }
-                    else if (transaction.status === 'aborted') {
+                    else if (transaction.status === "aborted") {
                         // Проверяем, есть ли pending после текущей aborted
                         const hasPendingAfter = index < lastPendingIndex;
                         if (hasPendingAfter) {
@@ -73,7 +73,7 @@ export class ResourceRef {
                 }
                 else {
                     // До первой pending транзакции
-                    if (transaction.status === 'committed') {
+                    if (transaction.status === "committed") {
                         // Применяем и убираем из очереди
                         const patches = transaction.patches;
                         currentData = applyPatches(currentData, patches);
@@ -94,19 +94,19 @@ export class ResourceRef {
         const transaction = {
             patches: [],
             inversePatches: [],
-            status: 'pending',
+            status: "pending",
             abort() {
-                if (this.status !== 'pending')
+                if (this.status !== "pending")
                     return;
-                this.status = 'aborted';
+                this.status = "aborted";
                 reapplyTransactions();
             },
             commit() {
-                if (this.status !== 'pending')
+                if (this.status !== "pending")
                     return;
-                this.status = 'committed';
+                this.status = "committed";
                 reapplyTransactions();
-            }
+            },
         };
         const updateFn = (data, savedData, transactions) => {
             isSkipped = false;

package/dist/query/index.d.ts

@@ -1,8 +1,11 @@
-export * from './api/createResource';
-export * from './api/createOperation';
-export * from './api/resetAllQueriesCache';
-export * from './api/createResourceDuplicator';
-export * from './SKIP_TOKEN';
-export * from './react/useResourceAgent';
-export * from './react/useResourceRef';
-export * from './react/useOperationAgent';
+export * from "./api/createCommand";
+export * from "./react/useCommandAgent";
+export * from "./api/createResource";
+export * from "./api/createResourceDuplicator";
+export * from "./api/resetAllQueriesCache";
+export * from "./SKIP_TOKEN";
+export * from "./types";
+export * from "./react/useResourceAgent";
+export * from "./react/useResourceRef";
+export * from "./api/createOperation";
+export * from "./react/useOperationAgent";

package/dist/query/index.js

@@ -1,8 +1,14 @@
-export * from './api/createResource';
-export * from './api/createOperation';
-export * from './api/resetAllQueriesCache';
-export * from './api/createResourceDuplicator';
-export * from './SKIP_TOKEN';
-export * from './react/useResourceAgent';
-export * from './react/useResourceRef';
-export * from './react/useOperationAgent';
+// Command API
+export * from "./api/createCommand";
+export * from "./react/useCommandAgent";
+// Resource API
+export * from "./api/createResource";
+export * from "./api/createResourceDuplicator";
+export * from "./api/resetAllQueriesCache";
+export * from "./SKIP_TOKEN";
+export * from "./types";
+export * from "./react/useResourceAgent";
+export * from "./react/useResourceRef";
+// Deprecated Operation API (backward compatibility)
+export * from "./api/createOperation";
+export * from "./react/useOperationAgent";

package/dist/query/lib/IndirectMap.js

@@ -22,7 +22,7 @@ export class IndirectMap {
     get(key) {
         const item = this._map.get(key);
         if (!item) {
-            const isObject = typeof key === 'object' && key !== null;
+            const isObject = typeof key === "object" && key !== null;
             if (!isObject) {
                 return undefined;
             }
@@ -40,7 +40,7 @@ export class IndirectMap {
             this._map.set(key, value);
         }
         else {
-            const isObject = typeof key === 'object' && key !== null;
+            const isObject = typeof key === "object" && key !== null;
             if (!isObject) {
                 this._map.set(key, value);
                 return;
@@ -61,7 +61,7 @@ export class IndirectMap {
      * @param key
      */
     delete(key) {
-        const isObject = typeof key === 'object' && key !== null;
+        const isObject = typeof key === "object" && key !== null;
         if (isObject) {
             const cachedKey = this._getCachedKey(key);
             if (cachedKey) {
@@ -73,7 +73,7 @@ export class IndirectMap {
     }
     has(key) {
         const has = this._map.has(key);
-        if (!has && typeof key === 'object' && key !== null) {
+        if (!has && typeof key === "object" && key !== null) {
             const cachedKey = this._getCachedKey(key);
             if (!cachedKey) {
                 return false;

package/dist/query/lib/ReactiveCache.d.ts

@@ -1,5 +1,5 @@
 import { Observable, Subject } from "rxjs";
-import { ReadableSignalLike } from "@/signals/types";
+import { ReadableSignalLike } from "../../signals/types";
 type Options<VALUE> = {
     /**
      * Начальное состояние кэша

package/dist/query/react/useCommandAgent.d.ts

@@ -0,0 +1,24 @@
+import type { CommandAgentInstance, CommandDefinition, CommandQueryState, Prettify } from "../../query/types";
+type WithAgent<D extends CommandDefinition> = {
+    createAgent: () => CommandAgentInstance<D>;
+};
+type TriggerFn<D extends CommandDefinition> = (args: D["Args"]) => Promise<D["Data"]>;
+type Result<D extends CommandDefinition> = [TriggerFn<D>, Prettify<CommandQueryState<D>>];
+/**
+ * React hook для работы с командой (Command).
+ *
+ * Возвращает кортеж `[trigger, state]`:
+ * - `trigger(args)` — инициирует выполнение команды и возвращает Promise с результатом.
+ * - `state` — реактивное состояние выполнения команды.
+ *
+ * @example
+ * ```tsx
+ * const [updateUser, state] = useCommandAgent(api.updateUser);
+ *
+ * const handleSubmit = async () => {
+ *   const result = await updateUser({ id: 1, name: 'New Name' });
+ * };
+ * ```
+ */
+export declare function useCommandAgent<D extends CommandDefinition>(op: WithAgent<D>): Result<D>;
+export {};

package/dist/query/react/useCommandAgent.js

@@ -0,0 +1,39 @@
+import { useConstant, useEventHandler } from "../../common/react";
+import { useSignal } from "../../signals/react";
+/**
+ * React hook для работы с командой (Command).
+ *
+ * Возвращает кортеж `[trigger, state]`:
+ * - `trigger(args)` — инициирует выполнение команды и возвращает Promise с результатом.
+ * - `state` — реактивное состояние выполнения команды.
+ *
+ * @example
+ * ```tsx
+ * const [updateUser, state] = useCommandAgent(api.updateUser);
+ *
+ * const handleSubmit = async () => {
+ *   const result = await updateUser({ id: 1, name: 'New Name' });
+ * };
+ * ```
+ */
+export function useCommandAgent(op) {
+    const agent = useConstant(() => op.createAgent());
+    const state = useSignal(agent.state$);
+    const trigger = useEventHandler((args) => {
+        agent.initiate(args);
+        return new Promise((resolve, reject) => {
+            const sub = agent.state$.obs.subscribe((s) => {
+                if (s.isDone && !s.isLoading) {
+                    sub.unsubscribe();
+                    if (s.isSuccess) {
+                        resolve(s.data);
+                    }
+                    else {
+                        reject(s.error);
+                    }
+                }
+            });
+        });
+    });
+    return [trigger, state];
+}

package/dist/query/react/useOperationAgent.d.ts

@@ -1,8 +1,6 @@
-import type { Prettify, OperationAgentInstanse, OperationDefinition, OperationQueryState } from "../../query/types";
-type WithAgent<D extends OperationDefinition> = {
-    createAgent: () => OperationAgentInstanse<D>;
-};
-type TriggerFn<D extends OperationDefinition> = (args: D['Args']) => Promise<D['Data']>;
-type Result<D extends OperationDefinition> = [TriggerFn<D>, Prettify<OperationQueryState<D>>];
-export declare function useOperationAgent<D extends OperationDefinition>(op: WithAgent<D>): Result<D>;
-export {};
+import { useCommandAgent } from "./useCommandAgent";
+/**
+ * @deprecated Use `useCommandAgent` instead. Will be removed in v0.6.0.
+ * @see useCommandAgent
+ */
+export declare const useOperationAgent: typeof useCommandAgent;

package/dist/query/react/useOperationAgent.js

@@ -1,23 +1,6 @@
-import { useConstant, useEventHandler } from "../../common/react";
-import { useSignal } from "../../signals/react";
-export function useOperationAgent(op) {
-    const agent = useConstant(() => op.createAgent());
-    const state = useSignal(agent.state$);
-    const trigger = useEventHandler((args) => {
-        agent.initiate(args);
-        return new Promise((resolve, reject) => {
-            const sub = agent.state$.obs.subscribe((s) => {
-                if (s.isDone && !s.isLoading) {
-                    sub.unsubscribe();
-                    if (s.isSuccess) {
-                        resolve(s.data);
-                    }
-                    else {
-                        reject(s.error);
-                    }
-                }
-            });
-        });
-    });
-    return [trigger, state];
-}
+import { useCommandAgent } from "./useCommandAgent";
+/**
+ * @deprecated Use `useCommandAgent` instead. Will be removed in v0.6.0.
+ * @see useCommandAgent
+ */
+export const useOperationAgent = useCommandAgent;

package/dist/query/react/useResourceAgent.d.ts

@@ -1,6 +1,6 @@
-import { Prettify, ResourceDefinition, ResourceInstance, ResourceQueryState } from "@/query/types";
-import { SKIP } from "@/query/SKIP_TOKEN";
-import { DuplicatorDefinition, ResourceDuplicator } from "@/query/core/Resource/ResourceDuplicator";
+import { DuplicatorDefinition, ResourceDuplicator } from "../../query/core/Resource/ResourceDuplicator";
+import { SKIP } from "../../query/SKIP_TOKEN";
+import { Prettify, ResourceDefinition, ResourceInstance, ResourceQueryState } from "../../query/types";
 type Result<D extends ResourceDefinition> = Prettify<ResourceQueryState<D>>;
-export declare function useResourceAgent<D extends ResourceDefinition>(res: ResourceInstance<D> | ResourceDuplicator<DuplicatorDefinition<D>>, ...argss: D['Args'] extends void ? [] | [typeof SKIP] : [D['Args'] | typeof SKIP]): Result<D>;
+export declare function useResourceAgent<D extends ResourceDefinition>(res: ResourceInstance<D> | ResourceDuplicator<DuplicatorDefinition<D>>, ...argss: D["Args"] extends void ? [] | [typeof SKIP] : [D["Args"] | typeof SKIP]): Result<D>;
 export {};

package/dist/query/react/useResourceAgent.js

@@ -1,7 +1,7 @@
 import React from "react";
 import { useConstant } from "../../common/react";
-import { useSignal } from "../../signals/react";
 import { SKIP } from "../../query/SKIP_TOKEN";
+import { useSignal } from "../../signals/react";
 export function useResourceAgent(res, ...argss) {
     const args = (argss[0] === SKIP ? SKIP : argss[0]);
     const prevArgsRef = React.useRef(SKIP);

package/dist/query/react/useResourceRef.d.ts

@@ -1,5 +1,5 @@
 import { SKIP } from "../../query/SKIP_TOKEN";
-import type { Prettify, ResourceDefinition, ResourceInstance, ResourceRefInstanse } from "../../query/types";
-type Result<D extends ResourceDefinition> = Prettify<ResourceRefInstanse<D>>;
-export declare function useResourceRef<D extends ResourceDefinition>(res: ResourceInstance<D>, ...argss: D['Args'] extends void ? [] | [typeof SKIP] : [D['Args'] | typeof SKIP]): Result<D>;
+import type { Prettify, ResourceDefinition, ResourceInstance, ResourceRefInstance } from "../../query/types";
+type Result<D extends ResourceDefinition> = Prettify<ResourceRefInstance<D>>;
+export declare function useResourceRef<D extends ResourceDefinition>(res: ResourceInstance<D>, ...argss: D["Args"] extends void ? [] | [typeof SKIP] : [D["Args"] | typeof SKIP]): Result<D>;
 export {};

package/dist/query/react/useResourceRef.js

@@ -1,8 +1,13 @@
 import React from "react";
+import { shallowEqual } from "../../common/utils/shallowEqual";
 import { SKIP } from "../../query/SKIP_TOKEN";
 export function useResourceRef(res, ...argss) {
     const args = (argss[0] === SKIP ? SKIP : argss[0]);
+    const stableArgsRef = React.useRef(args);
+    if (!shallowEqual(stableArgsRef.current, args)) {
+        stableArgsRef.current = args;
+    }
     return React.useMemo(() => {
-        return res.createRef(args);
-    }, [args]);
+        return res.createRef(stableArgsRef.current);
+    }, [stableArgsRef.current]);
 }

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

@@ -0,0 +1,154 @@
+import { ReadableSignalLike } from "../../signals/types";
+import { ResourceDefinition, ResourceInstance } from "./Resource.types";
+import { FallbackOnNever, OnCacheEntryAdded, OnQueryStarted } from "./shared.types";
+/**
+ * Функция создания команды
+ */
+export type CommandCreateFn<ARGS, RESULT, SELECTED = never> = (options: CommandCreateOptions<CommandDefinition<ARGS, RESULT, SELECTED>>) => CommandInstance<CommandDefinition<ARGS, RESULT, SELECTED>>;
+/**
+ * Опции создания команды
+ */
+export type CommandCreateOptions<D extends CommandDefinition> = {
+    /** Функция селектора для преобразования результата команды */
+    select?: (data: D["Result"]) => D["Selected"];
+    /** Функция выполнения команды */
+    queryFn: (args: D["Args"]) => Promise<D["Result"]>;
+    /** Связанные ресурсы */
+    link?: (link: <RD extends ResourceDefinition>(options: LinkOptions<D, RD>) => void) => void;
+    /**
+     * Время жизни кеша в миллисекундах. По умолчанию 1_000 (1 секунда).
+     * Если указано false - кеш не удаляется автоматически.
+     */
+    cacheLifetime?: number | false;
+    /**
+     * Хук, вызываемый при добавлении нового элемента в кеш.
+     * Также позволяет отследить:
+     *  - когда данные были загружены (впервые)
+     *  - когда элемент был удален из кеша
+     */
+    onCacheEntryAdded?: OnCacheEntryAdded<D["Args"], D["Data"]>;
+    /**
+     * Хук, вызываемый при старте запроса.
+     * Также позволяет отследить:
+     * - завершение запроса с результатом или ошибкой
+     */
+    onQueryStarted?: OnQueryStarted<D["Args"], D["Result"]>;
+    /**
+     * Настройка отображения в devtools
+     */
+    devtoolsName?: string | false;
+};
+/**
+ * Настройки связи команды с ресурсом
+ */
+export type LinkOptions<D extends CommandDefinition, RD extends ResourceDefinition> = {
+    /**
+     * Целевой ресурс, с которым связывается команда
+     * @required
+     */
+    resource: ResourceInstance<RD>;
+    /**
+     * Функция для получения аргументов ресурса из аргументов команды.
+     * Используется для определения какой именно элемент в кэше ресурса нужно обновить
+     * @required
+     */
+    forwardArgs: (args: D["Args"]) => RD["Args"];
+    /**
+     * Флаг для инвалидации (очистки) кэша ресурса после выполнения команды.
+     * При true - кэш будет очищен и ресурс будет перезагружен при следующем обращении
+     * @optional @default false
+     */
+    invalidate?: boolean;
+    /**
+     * Флаг для блокировки ресурса во время выполнения команды.
+     * При true - ресурс будет заблокирован и не сможет выполнять новые запросы
+     * @optional @default false
+     */
+    lock?: boolean;
+    /**
+     * Функция для обновления кэша ресурса после успешного выполнения команды.
+     * Получает draft объект для мутации, аргументы команды и результат команды
+     * @optional
+     */
+    update?: (tools: {
+        /** Immer draft объект для мутации кэша ресурса */
+        draft: RD["Data"];
+        /** Аргументы, с которыми была вызвана команда */
+        args: D["Args"];
+        /** Результат выполнения команды */
+        data: D["Data"];
+    }) => void | RD["Data"] | Promise<RD["Data"]>;
+    /**
+     * Функция для оптимистичного обновления кэша ресурса ДО выполнения команды.
+     * Позволяет обновить UI немедленно, до получения ответа от сервера
+     * @optional
+     */
+    optimisticUpdate?: (tools: {
+        /** Immer draft объект для мутации кэша ресурса */
+        draft: RD["Data"];
+        /** Аргументы, с которыми была вызвана команда */
+        args: D["Args"];
+    }) => void | RD["Data"] | Promise<RD["Data"]>;
+    /**
+     * Функция для создания нового элемента в кэше ресурса.
+     * Используется когда команда создает новую сущность, которую нужно добавить в кэш
+     * @optional
+     */
+    create?: (tools: {
+        /** Аргументы, с которыми была вызвана команда */
+        args: D["Args"];
+        /** Результат выполнения команды */
+        data: D["Data"];
+    }) => RD["Data"] | Promise<RD["Data"]>;
+};
+/**
+ * Определение типов команды
+ */
+export type CommandDefinition<A = any, R = any, S = any> = {
+    Args: A;
+    Result: R;
+    Selected: S;
+    Data: FallbackOnNever<S, R>;
+};
+/**
+ * Экземпляр команды
+ */
+export type CommandInstance<D extends CommandDefinition> = {
+    /** Создает агента для выполнения команды */
+    createAgent(): CommandAgentInstance<D>;
+    /**
+     * Выполняет команду с указанными аргументами
+     * @deprecated
+     */
+    mutate: (args: D["Args"]) => Promise<D["Data"]>;
+};
+/**
+ * Агент для выполнения команды
+ */
+export type CommandAgentInstance<D extends CommandDefinition> = {
+    /** Observable состояния выполнения команды */
+    state$: ReadableSignalLike<CommandQueryState<D>>;
+    /** Инициирует выполнение команды с указанными аргументами */
+    initiate(args: D["Args"]): void;
+    /** Создает новый агент команды */
+    createAgent(): CommandAgentInstance<D>;
+};
+/**
+ * Состояние выполнения команды
+ */
+export type CommandQueryState<D extends CommandDefinition> = {
+    /** Выполняется ли команда в данный момент */
+    isLoading: boolean;
+    /** Завершена ли команда */
+    isDone: boolean;
+    /** Успешно ли завершена команда (false по умолчанию) */
+    isSuccess: boolean;
+    /** Произошла ли ошибка при выполнении команды (false по умолчанию) */
+    isError: boolean;
+    /** Оригинал ошибки, если есть */
+    error: unknown | undefined;
+    /** Результат выполнения команды */
+    data: D["Data"] | undefined;
+    /** Аргументы команды */
+    args: D["Args"];
+};

package/dist/query/types/Command.types.js

@@ -0,0 +1 @@
+export {};