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

package/dist/query/core/Opertation/Operation.js

@@ -1,211 +1,4 @@
-import { PromiseResolver } from "../../../common/utils";
-import { Batcher } from "../../../signals";
-import { QueriesCache } from "../QueriesCache";
-import { QueriesLifetimeHooks } from "../QueriesLifetimeHooks";
-import { OperationAgent } from "./OperationAgent";
-import { ResetAllQueriesSignal } from "../../../query/core/ResetAllQueriesSignal";
-class OperationQueryState {
-    static create() {
-        return {
-            arg: null,
-            data: null,
-            error: null,
-            isError: false,
-            isRepeating: false,
-            isDone: false,
-            isSuccess: false,
-            isLoading: false,
-            isInitiated: false,
-        };
-    }
-    static load(state = OperationQueryState.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 Operation {
-    _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(OperationQueryState.create());
-            });
-        });
-    }
-    _createLinks() {
-        this._options.link?.((linkOptions) => {
-            this._links.push(linkOptions);
-        });
-    }
-    createAgent() {
-        return new OperationAgent(this);
-    }
-    getQueryCache(args) {
-        return this._queriesCache.getQueryCache(args);
-    }
-    createQueryCache(args, state = OperationQueryState.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 = OperationQueryState.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(OperationQueryState.success(state, data));
-                /**
-                 * Обновляем связанные ресурсы
-                 */
-                linksMeta.forEach(({ link, ref, state }) => {
-                    if (link.update && ref.has) {
-                        // TODO подумать, нужно ли добавлять обработку, если patch() -> null (и в принце про работу patch)
-                        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(OperationQueryState.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;
-    }
-}
+/**
+ * @deprecated Use `Command` from '../Command/Command' instead. Will be removed in v0.6.0.
+ */
+export { Command as Operation } from '../Command/Command';

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

@@ -1,19 +1,4 @@
-import { OperationAgentInstanse, OperationDefinition } from "@/query/types";
-import type { Operation } from "./Operation";
-export declare class OperationAgent<D extends OperationDefinition> implements OperationAgentInstanse<D> {
-    private _operation;
-    private _operations$;
-    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(_operation: Operation<D>);
-    private _next;
-    initiate(args: D["Args"]): void;
-    createAgent(): OperationAgentInstanse<D>;
-}
+/**
+ * @deprecated Use `CommandAgent` from '../Command/CommandAgent' instead. Will be removed in v0.6.0.
+ */
+export { CommandAgent as OperationAgent } from '../Command/CommandAgent';

package/dist/query/core/Opertation/OperationAgent.js

@@ -1,54 +1,4 @@
-import { Computed, Signal } from "../../../signals";
-export class OperationAgent {
-    _operation;
-    _operations$ = Signal.create({
-        current$: null,
-    }, { isDisabled: true });
-    state$ = Computed.create(() => {
-        const operations = this._operations$.get();
-        const currState = operations.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(_operation) {
-        this._operation = _operation;
-    }
-    _next(newCache) {
-        this._operations$.set({
-            current$: newCache,
-        });
-    }
-    initiate(args) {
-        const cache = this._operation.getQueryCache(args);
-        if (!cache) {
-            const newCache = this._operation.initiate(args);
-            this._next(newCache);
-            return;
-        }
-        // Всегда запускаем операцию заново, так как операции обычно не кэшируются как ресурсы
-        const newCache = this._operation.initiate(args, { cache });
-        this._next(newCache);
-    }
-    createAgent() {
-        return new OperationAgent(this._operation);
-    }
-}
+/**
+ * @deprecated Use `CommandAgent` from '../Command/CommandAgent' instead. Will be removed in v0.6.0.
+ */
+export { CommandAgent as OperationAgent } from '../Command/CommandAgent';

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

@@ -1,4 +1,4 @@
-import { ReactiveCache } from "@/query/lib/ReactiveCache";
+import { ReactiveCache } from "../../query/lib/ReactiveCache";
 export declare class QueriesCache<KEY, VALUE> {
     private _cacheLifeTime;
     private readonly _cache;

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

@@ -1,5 +1,5 @@
 import { Subject } from "rxjs";
-import { OnCacheEntryAdded, OnQueryStarted } from "@/query/types";
+import { OnCacheEntryAdded, OnQueryStarted } from "../../query/types";
 type Options<ARGS, DATA> = {
     onCacheEntryAdded?: OnCacheEntryAdded<ARGS, DATA>;
     onQueryStarted?: OnQueryStarted<ARGS, DATA>;

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

@@ -1,5 +1,5 @@
-import { ReactiveCache } from "@/query/lib/ReactiveCache";
-import type { ResourceCreateOptions, ResourceDefinition, ResourceInstance, ResourceRefInstanse, ResourceTransaction } from "@/query/types";
+import { ReactiveCache } from "../../../query/lib/ReactiveCache";
+import type { ResourceCreateOptions, ResourceDefinition, ResourceInstance, ResourceRefInstanse, ResourceTransaction } from "../../../query/types";
 import { ResourceAgent } from "./ResourceAgent";
 export type CoreResourceQueryState<D extends ResourceDefinition> = {
     transactions: ResourceTransaction[] | null;

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

@@ -1,4 +1,4 @@
-import { ResourceAgentInstance, ResourceDefinition } from "@/query/types";
+import { ResourceAgentInstance, ResourceDefinition } from "../../../query/types";
 import type { Resource } from "./Resource";
 export declare class ResourceAgent<D extends ResourceDefinition> implements ResourceAgentInstance<D> {
     private _resource;

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

@@ -1,7 +1,7 @@
 import { Computed, Signal } from "../../../signals";
 export class ResourceAgent {
     _resource;
-    _resources$ = Signal.create({
+    _resources$ = Signal.state({
         previous$: null,
         current$: null,
     }, { isDisabled: true });

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

@@ -1,6 +1,6 @@
-import { ResourceDefinition } from "@/query/types";
+import { ResourceDefinition } from "../../../query/types";
 import { CoreResourceQueryState, Resource } from "./Resource";
-import { ReadableSignalLike } from "@/signals/types";
+import { ReadableSignalLike } from "../../../signals/types";
 import { Observable, Subject } from "rxjs";
 import { ResourceDuplicatorAgent } from "./ResourceDuplicatorAgent";
 export type DuplicatorOptions<D extends DuplicatorDefinition> = {
@@ -33,7 +33,7 @@ export declare class ResourceDuplicator<D extends DuplicatorDefinition> {
     createAgent: () => ResourceDuplicatorAgent<D>;
     /** @deprecated */
     d_init(args: D['ARGS_ITEM'][]): {
-        value$: import("@/signals/types").ComputeFn<State<D>>;
+        value$: import("../../../signals/types").ComputeFn<State<D>>;
     };
 }
 export declare class ComputedReactiveCache<T> {

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

@@ -1,4 +1,4 @@
-import { Signal, signalize } from "@/signals";
+import { Signal, signalize } from "../../../signals";
 import { finalize, ReplaySubject, share, Subject, takeUntil, timer } from "rxjs";
 import { ResourceDuplicatorAgent } from "./ResourceDuplicatorAgent";
 export class ResourceDuplicator {

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

@@ -1,5 +1,5 @@
-import { ResourceAgentInstance } from "@/query/types";
-import { ResourceDuplicator, DuplicatorDefinition } from "@/query/core/Resource/ResourceDuplicator";
+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']> {
     private _resource;
     private _resources$;

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 });

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

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

package/dist/query/index.d.ts

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

package/dist/query/index.js

@@ -1,8 +1,13 @@
+// Command API
+export * from './api/createCommand';
+export * from './react/useCommandAgent';
+// Resource API
 export * from './api/createResource';
-export * from './api/createOperation';
-export * from './api/resetAllQueriesCache';
 export * from './api/createResourceDuplicator';
+export * from './api/resetAllQueriesCache';
 export * from './SKIP_TOKEN';
 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/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 { Prettify, CommandAgentInstance, CommandDefinition, CommandQueryState } 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 { Prettify, ResourceDefinition, ResourceInstance, ResourceQueryState } from "../../query/types";
+import { SKIP } from "../../query/SKIP_TOKEN";
+import { DuplicatorDefinition, ResourceDuplicator } from "../../query/core/Resource/ResourceDuplicator";
 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 {};