@fozy-labs/rx-toolkit 0.4.2 → 0.4.4

package/README.md

@@ -41,11 +41,11 @@ RxToolkit решает эти проблемы, предоставляя сво
 
 ###### Создаем сигнал
 ```typescript
-// Описываете логику в обычном JavaScript
+// Описываем логику в обычном JavaScript
 const store = {
-  count$: new Signal(0),
-  doubled$: new Computed(() => store.count$.value * 2),
-  increment: () => store.count$.next(store.count$.value + 1)
+    count$: new Signal(0),
+    doubled$: new Computed(() => store.count$.value * 2),
+    increment: () => store.count$.value++,
 };
 ```
 
@@ -71,7 +71,6 @@ $: count = store.count$;
 
 ```typescript
 // Создаем Observable
-
 const clicker$ = fromEvent(document, 'click').pipe(
     debounceTime(300),
     scan(count => count + 1, 0),

package/dist/{devtools → common/devtools}/combineDevtools.d.ts

@@ -1,2 +1,2 @@
-import { DevtoolsLike } from "../query/types/devtools";
+import { DevtoolsLike } from "./types";
 export declare function combineDevtools(...devtools: DevtoolsLike[]): DevtoolsLike;

package/dist/{devtools → common/devtools}/index.d.ts

@@ -1,2 +1,3 @@
 export * from './reduxDevtools';
 export * from './combineDevtools';
+export * from './types';

package/dist/{devtools → common/devtools}/index.js

@@ -1,2 +1,3 @@
 export * from './reduxDevtools';
 export * from './combineDevtools';
+export * from './types';

package/dist/common/devtools/reduxDevtools.d.ts

@@ -0,0 +1,16 @@
+import { DevtoolsLike } from "./types";
+interface ReduxDevtoolsExtension {
+    connect(options: {
+        name: string;
+    }): ReduxDevtoolsConnection;
+}
+interface ReduxDevtoolsConnection {
+    init(state: any): void;
+    send(action: any, state: any): void;
+}
+type Options = {
+    name?: string;
+    driver?: ReduxDevtoolsExtension;
+};
+export declare function reduxDevtools(options?: Options): DevtoolsLike;
+export {};

package/dist/{devtools → common/devtools}/reduxDevtools.js

@@ -1,8 +1,11 @@
-import { Batcher } from "../signals";
-export function reduxDevtools() {
+import { Batcher } from "../../signals";
+export function reduxDevtools(options = {}) {
+    const devtools = options.driver ?? window.__REDUX_DEVTOOLS_EXTENSION__;
+    if (!devtools) {
+        throw new Error('Redux Devtools extension is not installed');
+    }
     let state = {};
-    // @ts-ignore
-    const reduxDevtools = window.__REDUX_DEVTOOLS_EXTENSION__.connect({ name: 'RxToolkit' });
+    const reduxDevtools = devtools.connect({ name: options.name ?? 'RxToolkit' });
     reduxDevtools.init(state);
     const scheduler = Batcher.scheduler(Infinity);
     const updateFn = () => {

package/dist/{query/api → common/options}/DefaultOptions.d.ts

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

package/dist/{query/api → common/options}/DefaultOptions.js

@@ -1,4 +1,4 @@
-import { SharedOptions } from "../../query/core/SharedOptions";
+import { SharedOptions } from "./SharedOptions";
 export class DefaultOptions {
     static update(part) {
         if (part.DEVTOOLS !== undefined)

package/dist/{query/core → common/options}/SharedOptions.d.ts

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

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

@@ -0,0 +1 @@
+export * from './DefaultOptions';

package/dist/common/options/index.js

@@ -0,0 +1 @@
+export * from './DefaultOptions';

package/dist/{react-hooks → common/react}/index.d.ts

@@ -1,5 +1,4 @@
-export * from './useSignal';
+export * from './useConstant';
+export * from './useEventHandler';
 export * from './useObservable';
 export * from './useSyncObservable';
-export * from './useEventHandler';
-export * from './useConstant';

package/dist/{react-hooks → common/react}/index.js

@@ -1,5 +1,4 @@
-export * from './useSignal';
+export * from './useConstant';
+export * from './useEventHandler';
 export * from './useObservable';
 export * from './useSyncObservable';
-export * from './useEventHandler';
-export * from './useConstant';

package/dist/{react-hooks → common/react}/useObservable.js

@@ -1,7 +1,7 @@
 import React from 'react';
-import { useEventHandler } from "../react-hooks/useEventHandler";
 import { BehaviorSubject } from 'rxjs';
-import { useConstant } from "../react-hooks/useConstant";
+import { useConstant } from "./useConstant";
+import { useEventHandler } from "./useEventHandler";
 const NONE = Symbol('NONE');
 /**
  * Hook for automatically subscribing and unsubscribing from an Observable.

package/dist/{react-hooks → common/react}/useSyncObservable.js

@@ -1,6 +1,7 @@
 import React from 'react';
 import { BehaviorSubject } from 'rxjs';
-import { useConstant, useEventHandler } from "../react-hooks";
+import { useConstant } from "./useConstant";
+import { useEventHandler } from "./useEventHandler";
 const NONE = Symbol('NONE');
 /**
  * Hook for automatically subscribing and unsubscribing from an Observable.

package/dist/common/utils/PromiseResolver.d.ts

@@ -0,0 +1,7 @@
+export declare class PromiseResolver<T> {
+    private _resolve;
+    private _reject;
+    promise: Promise<T>;
+    resolve(value: T): void;
+    reject(reason?: any): void;
+}

package/dist/common/utils/PromiseResolver.js

@@ -0,0 +1,14 @@
+export class PromiseResolver {
+    _resolve;
+    _reject;
+    promise = new Promise((resolve, reject) => {
+        this._resolve = resolve;
+        this._reject = reject;
+    });
+    resolve(value) {
+        this._resolve(value);
+    }
+    reject(reason) {
+        this._reject(reason);
+    }
+}

package/dist/common/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './PromiseResolver';

package/dist/common/utils/index.js

@@ -0,0 +1 @@
+export * from './PromiseResolver';

package/dist/index.d.ts

@@ -1,4 +1,5 @@
+export * from './common/devtools';
+export * from './common/options';
+export * from './common/react';
 export * from './query';
 export * from './signals';
-export * from './react-hooks';
-export * from './devtools';

package/dist/index.js

@@ -1,4 +1,5 @@
+export * from './common/devtools';
+export * from './common/options';
+export * from './common/react';
 export * from './query';
 export * from './signals';
-export * from './react-hooks';
-export * from './devtools';

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

@@ -1,7 +1,3 @@
-import type { OperationCreateOptions, OperationDefinition } from "../../query/types/Operation.types";
+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 `createOperation` instead.
- */
-export declare const createMutationApi: <ARGS, RESULT, SELECTED = never>(options: OperationCreateOptions<OperationDefinition<ARGS, RESULT, SELECTED>>) => Operation<OperationDefinition<ARGS, RESULT, SELECTED>>;

package/dist/query/api/createOperation.js

@@ -1,6 +1,2 @@
 import { Operation } from "../../query/core/Opertation/Operation";
 export const createOperation = ((options) => new Operation(options));
-/**
- * @deprecated Use `createOperation` instead.
- */
-export const createMutationApi = createOperation;

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

@@ -1,3 +1,3 @@
-import type { ResourceCreateOptions, ResourceDefinition } from "../../query/types/Resource.types";
+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/core/Opertation/Operation.d.ts

@@ -1,6 +1,5 @@
-import { ReactiveCache } from "../../../query/lib/ReactiveCache";
-import { FallbackOnNever } from "../../../query/types/shared.types";
-import { OperationCreateOptions, OperationDefinition, OperationInstance } from "../../../query/types/Operation.types";
+import type { ReactiveCache } from "../../../query/lib/ReactiveCache";
+import type { FallbackOnNever, OperationCreateOptions, OperationDefinition, OperationInstance } from "../../../query/types";
 import { QueriesCache } from "../QueriesCache";
 import { OperationAgent } from "./OperationAgent";
 export type CoreOperationQueryState<D extends OperationDefinition> = {

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

@@ -1,5 +1,6 @@
+import { PromiseResolver } from "../../../common/utils";
+import { SharedOptions } from "../../../common/options/SharedOptions";
 import { QueriesCache } from "../QueriesCache";
-import { SharedOptions } from "../SharedOptions";
 import { OperationAgent } from "./OperationAgent";
 class OperationQueryState {
     static create() {
@@ -50,7 +51,7 @@ class OperationQueryState {
 }
 export class Operation {
     _options;
-    _queriesCache = new QueriesCache('Operation');
+    _queriesCache = new QueriesCache(60_000, 'Operation');
     _links = [];
     constructor(_options) {
         this._options = _options;
@@ -104,9 +105,10 @@ export class Operation {
              */
             linksMeta.forEach(({ link, ref, state }) => {
                 if (link.update && ref.has) {
-                    ref.update((draft) => {
+                    // 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 }));
@@ -161,17 +163,3 @@ export class Operation {
         return resolver.promise;
     }
 }
-class PromiseResolver {
-    _resolve;
-    _reject;
-    promise = new Promise((resolve, reject) => {
-        this._resolve = resolve;
-        this._reject = reject;
-    });
-    resolve(value) {
-        this._resolve(value);
-    }
-    reject(reason) {
-        this._reject(reason);
-    }
-}

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

@@ -1,4 +1,4 @@
-import { OperationAgentInstanse, OperationDefinition } from "../../../query/types/Operation.types";
+import { OperationAgentInstanse, OperationDefinition } from "../../../query/types";
 import { Computed } from "../../../signals";
 import type { Operation } from "./Operation";
 export declare class OperationAgent<D extends OperationDefinition> implements OperationAgentInstanse<D> {
@@ -10,7 +10,7 @@ export declare class OperationAgent<D extends OperationDefinition> implements Op
         isSuccess: boolean;
         isError: boolean;
         error: {} | undefined;
-        data: NonNullable<import("../../types/shared.types").FallbackOnNever<D["Selected"], D["Result"]>> | undefined;
+        data: NonNullable<import("../../../query/types").FallbackOnNever<D["Selected"], D["Result"]>> | undefined;
         args: D["Args"];
     }>;
     constructor(_operation: Operation<D>);

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

@@ -6,7 +6,7 @@ export class OperationAgent {
     }, { disableDevtools: true });
     state$ = new Computed(() => {
         const operations = this._operations$.value;
-        const currState = operations.current$?.value;
+        const currState = operations.current$?.value$.value;
         // Нет текущего состояния — дефолт
         if (!currState) {
             return {

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

@@ -1,8 +1,9 @@
 import { ReactiveCache } from "../../query/lib/ReactiveCache";
 export declare class QueriesCache<KEY, VALUE> {
+    private _cacheLifeTime;
     private _logname;
     private readonly _cache;
-    constructor(_logname?: string);
+    constructor(_cacheLifeTime?: number | false, _logname?: string);
     getQueryCache(args: KEY): ReactiveCache<VALUE> | undefined;
     createQueryCache(args: KEY, initialState: VALUE): ReactiveCache<VALUE>;
 }

package/dist/query/core/QueriesCache.js

@@ -1,11 +1,11 @@
 import { IndirectMap } from "../../query/lib/IndirectMap";
 import { ReactiveCache } from "../../query/lib/ReactiveCache";
-import { Indexer } from "../../signals/base/Indexer";
-import { SharedOptions } from "./SharedOptions";
 export class QueriesCache {
+    _cacheLifeTime;
     _logname;
     _cache = new IndirectMap();
-    constructor(_logname = 'query') {
+    constructor(_cacheLifeTime = 60_000, _logname = 'query') {
+        this._cacheLifeTime = _cacheLifeTime;
         this._logname = _logname;
     }
     getQueryCache(args) {
@@ -14,20 +14,23 @@ export class QueriesCache {
     createQueryCache(args, initialState) {
         const cache = new ReactiveCache({
             initialState,
+            cacheLifeTime: this._cacheLifeTime,
         });
-        const stateDevtools = SharedOptions.DEVTOOLS?.state;
-        if (stateDevtools) {
-            const key = `${this._logname}:${JSON.stringify(args)}:i=${Indexer.getIndex()}`;
-            let devtools = stateDevtools(key, initialState);
-            cache.spy$.subscribe((state) => {
-                if (state === initialState)
-                    return;
-                devtools(state);
-            });
-            cache.onClean$.subscribe(() => {
-                devtools('$CLEANED');
-            });
-        }
+        // const stateDevtools = SharedOptions.DEVTOOLS?.state;
+        //
+        // if (stateDevtools) {
+        //     const key = `${this._logname}:${JSON.stringify(args)}:i=${Indexer.getIndex()}`;
+        //     let devtools = stateDevtools(key, initialState);
+        //
+        //     cache.spy$.subscribe((state) => {
+        //         if (state === initialState) return;
+        //         devtools(state);
+        //     });
+        //
+        //     cache.onClean$.subscribe(() => {
+        //         devtools('$CLEANED' as any);
+        //     });
+        // }
         cache.onClean$.subscribe(() => {
             this._cache.delete(args);
         });

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

@@ -1,6 +1,5 @@
 import { ReactiveCache } from "../../../query/lib/ReactiveCache";
-import type { ResourceCreateOptions, ResourceDefinition, ResourceInstance, ResourceRefInstanse, ResourceTransaction } from "../../../query/types/Resource.types";
-import { QueriesCache } from "../QueriesCache";
+import type { ResourceCreateOptions, ResourceDefinition, ResourceInstance, ResourceRefInstanse, ResourceTransaction } from "../../../query/types";
 import { ResourceAgent } from "./ResourceAgent";
 export type CoreResourceQueryState<D extends ResourceDefinition> = {
     transactions: ResourceTransaction[] | null;
@@ -21,7 +20,8 @@ export type CoreResourceQueryState<D extends ResourceDefinition> = {
 export type CoreResourceQueryCache<D extends ResourceDefinition> = ReactiveCache<CoreResourceQueryState<D>>;
 export declare class Resource<D extends ResourceDefinition> implements ResourceInstance<D> {
     private readonly _options;
-    readonly _queriesCache: QueriesCache<D["Args"], CoreResourceQueryState<D>>;
+    private readonly _queriesCache;
+    private readonly _hooks;
     constructor(_options: ResourceCreateOptions<D>);
     createAgent: () => ResourceAgent<D>;
     createRef: (args: D["Args"]) => ResourceRefInstanse<D>;
@@ -33,12 +33,6 @@ export declare class Resource<D extends ResourceDefinition> implements ResourceI
     decrementLock(args: D['Args'], options?: {
         cache?: CoreResourceQueryCache<D>;
     }): CoreResourceQueryCache<D> | null;
-    /**
-     * @deprecated
-     */
-    updateData_legacy(args: D['Args'], updateFn: (data: D['Data']) => D['Data'], options?: {
-        cache?: CoreResourceQueryCache<D>;
-    }): CoreResourceQueryCache<D> | null;
     update(args: D['Args'], updateFn: (data: D['Data'], savedData: D['Data'] | null, transactions: ResourceTransaction[] | null) => {
         data: D['Data'];
         transactions: ResourceTransaction[] | null;

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

@@ -1,5 +1,6 @@
-import { QueriesCache } from "../QueriesCache";
-import { SharedOptions } from "../SharedOptions";
+import { PromiseResolver } from "../../../common/utils";
+import { SharedOptions } from "../../../common/options/SharedOptions";
+import { QueriesCache } from "../../../query/core/QueriesCache";
 import { ResourceAgent } from "./ResourceAgent";
 import { ResourceRef } from "./ResourceRef";
 class ResourceQueryState {
@@ -90,11 +91,67 @@ class ResourceQueryState {
         };
     }
 }
+// TODO вынести и унифицировать; как-то организовать глобальные хуки и devtools через хуки
+class QueryHooks {
+    _options;
+    onCacheEntryAddedListeners = [];
+    onQueryStartedListeners = [];
+    constructor(_options) {
+        this._options = _options;
+        if (_options?.onCacheEntryAdded) {
+            this.onCacheEntryAddedListeners.push(_options.onCacheEntryAdded);
+        }
+        if (_options?.onQueryStarted) {
+            this.onQueryStartedListeners.push(_options.onQueryStarted);
+        }
+    }
+    onCacheEntryAdded = (args) => {
+        const cacheDataLoadedResolver = new PromiseResolver();
+        const cacheEntryRemovedResolver = new PromiseResolver();
+        this.onCacheEntryAddedListeners.forEach((listener) => {
+            listener(args, {
+                $cacheDataLoaded: cacheDataLoadedResolver.promise,
+                $cacheEntryRemoved: cacheEntryRemovedResolver.promise,
+            });
+        });
+        return {
+            cacheDataLoaded: () => cacheDataLoadedResolver.resolve(),
+            cacheEntryRemoved: () => cacheEntryRemovedResolver.resolve(),
+        };
+    };
+    onQueryStarted = (args) => {
+        const queryFulfilledResolver = new PromiseResolver();
+        this.onQueryStartedListeners.forEach((listener) => {
+            listener(args, {
+                $queryFulfilled: queryFulfilledResolver.promise
+            });
+        });
+        return {
+            fulfilledSuccess: (data) => {
+                queryFulfilledResolver.resolve({
+                    data,
+                    error: undefined,
+                    isError: false
+                });
+            },
+            fulfilledError: (error) => {
+                queryFulfilledResolver.resolve({
+                    data: undefined,
+                    error,
+                    isError: true
+                });
+            }
+        };
+    };
+}
 export class Resource {
     _options;
-    _queriesCache = new QueriesCache('Resource');
+    _queriesCache;
+    _hooks;
     constructor(_options) {
         this._options = _options;
+        this._hooks = new QueryHooks(_options);
+        this._queriesCache = new QueriesCache(_options.cacheLifetime, 'Resource');
     }
     createAgent = () => {
         return new ResourceAgent(this);
@@ -106,7 +163,18 @@ export class Resource {
         return this._queriesCache.getQueryCache(args);
     }
     createQueryCache(args) {
-        return this._queriesCache.createQueryCache(args, ResourceQueryState.create());
+        const cache = this._queriesCache.createQueryCache(args, ResourceQueryState.create());
+        const hookResolvers = this._hooks.onCacheEntryAdded(args);
+        const spySub = cache.spy$.subscribe((state) => {
+            if (!state.isDone)
+                return;
+            hookResolvers.cacheDataLoaded();
+            spySub.unsubscribe();
+        });
+        cache.onClean$.subscribe(() => {
+            hookResolvers.cacheEntryRemoved();
+        });
+        return cache;
     }
     incrementLock(args, options) {
         let cache = options?.cache ?? this.getQueryCache(args);
@@ -124,22 +192,6 @@ export class Resource {
         cache.next(ResourceQueryState.decrementLock(cache.value));
         return cache;
     }
-    /**
-     * @deprecated
-     */
-    updateData_legacy(args, updateFn, options) {
-        let cache = options?.cache ?? this.getQueryCache(args);
-        if (!cache) {
-            return null;
-        }
-        const cacheValue = cache.value;
-        if (!cacheValue.isDone) {
-            return cache;
-        }
-        const newData = updateFn(cacheValue.data);
-        cache.next(ResourceQueryState.setData(cache.value, newData));
-        return cache;
-    }
     update(args, updateFn, options) {
         let cache = options?.cache ?? this.getQueryCache(args);
         if (!cache) {
@@ -154,23 +206,23 @@ export class Resource {
         return cache;
     }
     initiate(args, options) {
-        let cache = options?.cache ?? this._queriesCache.getQueryCache(args);
+        let cache = options?.cache ?? this.getQueryCache(args);
         const state = ResourceQueryState.load(cache?.value, args);
         if (!cache) {
-            cache = this._queriesCache.createQueryCache(args, state);
-        }
-        else {
-            cache.next(state);
+            cache = this.createQueryCache(args);
         }
+        cache.next(state);
         let abortController = state.abortController;
         abortController?.abort();
         abortController = new AbortController();
         const query = this._options.queryFn(args, { abortSignal: abortController.signal });
+        const hookResolvers = this._hooks.onQueryStarted(args);
         query
             .then((data) => {
             if (abortController.signal.aborted) {
                 return;
             }
+            hookResolvers.fulfilledSuccess(data);
             const selectedData = this._options.select ? this._options.select(data) : data;
             cache.next(ResourceQueryState.success(state, selectedData));
         })
@@ -178,7 +230,8 @@ export class Resource {
             if (abortController.signal.aborted) {
                 return;
             }
-            SharedOptions.onError?.(error);
+            hookResolvers.fulfilledError(error);
+            SharedOptions.onError?.(error); // TODO перенести в хуки
             cache.next(ResourceQueryState.error(state, error));
         });
         return cache;

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

@@ -1,5 +1,5 @@
 import { Computed } from "../../../signals";
-import { ResourceAgentInstance, ResourceDefinition } from "../../../query/types/Resource.types";
+import { ResourceAgentInstance, ResourceDefinition } from "../../../query/types";
 import type { Resource } from "./Resource";
 export declare class ResourceAgent<D extends ResourceDefinition> implements ResourceAgentInstance<D> {
     private _resource;
@@ -30,5 +30,5 @@ export declare class ResourceAgent<D extends ResourceDefinition> implements Reso
     constructor(_resource: Resource<D>);
     private _next;
     initiate(args: D["Args"], force?: boolean): void;
-    createAgent: () => ResourceAgentInstance<D>;
+    complete(): void;
 }

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

@@ -8,7 +8,7 @@ export class ResourceAgent {
     state$ = new Computed(() => {
         const resources = this._resources$.value;
         let prevState;
-        const currState = resources.current$?.value;
+        const currState = resources.current$?.value$.value;
         if (!currState?.isDone) {
             prevState = resources.previous$?.value;
         }
@@ -81,7 +81,8 @@ export class ResourceAgent {
             this._next(cache);
         }
     }
-    createAgent = () => {
-        return this;
-    };
+    complete() {
+        this.state$.complete();
+        this._resources$.complete();
+    }
 }

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

@@ -1,5 +1,5 @@
+import { ResourceDefinition, ResourceRefInstanse, ResourceTransaction } from "../../../query/types";
 import { Resource } from "./Resource";
-import { ResourceDefinition, ResourceRefInstanse, ResourceTransaction } from "../../types/Resource.types";
 export declare class ResourceRef<D extends ResourceDefinition> implements ResourceRefInstanse<D> {
     private readonly _resource;
     private readonly _args;
@@ -10,9 +10,6 @@ export declare class ResourceRef<D extends ResourceDefinition> implements Resour
         unlock: () => void;
     };
     unlockOne(): void;
-    update(updateFn: (data: D["Data"]) => D["Data"]): {
-        rollback: () => void;
-    };
     patch(patchFn: (data: D["Data"]) => void): ResourceTransaction | null;
     create(data: D["Data"]): void;
     invalidate(): void;