@vladimirdev635/gql-client-react 0.0.61 → 0.0.62

package/index.d.ts

@@ -1,3 +1,3 @@
-export { type OperationLoadingState, type OperationSuccessState, type OperationFailureState, type OperationState, loadingState, useOperation, } from './useOperation.jsx';
-export { type LazyOperationInitialState, type LazyOperationState, type UseLazyOperationReturnType, lazyInitialState, useLazyOperation, } from './useLazyOperation.jsx';
+export { type OperationLoadingState, type OperationSuccessState, type OperationFailureState, type OperationState, useOperation, } from './useOperation.jsx';
+export { type LazyOperationInitialState, type LazyOperationState, type UseLazyOperationReturnType, type LazyOperationExecuteReturnType, } from './use-lazy-operation/index.js';
 export { useSubscription } from './useSubscription.jsx';

package/index.js

@@ -1,3 +1,2 @@
-export { loadingState, useOperation, } from './useOperation.jsx';
-export { lazyInitialState, useLazyOperation, } from './useLazyOperation.jsx';
+export { useOperation, } from './useOperation.jsx';
 export { useSubscription } from './useSubscription.jsx';

package/loading-state.d.ts

@@ -0,0 +1,3 @@
+export declare const loadingState: Readonly<{
+    readonly state: "loading";
+}>;

package/loading-state.js

@@ -0,0 +1 @@
+export const loadingState = Object.freeze({ state: 'loading' });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@vladimirdev635/gql-client-react",
-    "version": "0.0.61",
+    "version": "0.0.62",
     "type": "module",
     "main": "./index.js",
     "types": "./index.d.ts",

package/tests/useLazyOperation.spec.js

@@ -1,4 +1,4 @@
-import { useLazyOperation } from '../useLazyOperation.jsx';
+import { useLazyOperation } from '../use-lazy-operation/index.js';
 import { describe, expect, it } from 'vitest';
 import { renderHook, act } from '@testing-library/react';
 import assert from 'assert';
@@ -11,10 +11,12 @@ describe('useLazyOperation', () => {
         expect(result.current[1].state.state).toBe('initial');
     });
     it('Should return loading state after invoking, then success state', async () => {
-        const executor = async () => ({
-            result: { a: 1 },
-            response: new Response()
-        });
+        const executor = {
+            executeSync: async () => ({
+                result: { a: 1 },
+                response: new Response()
+            }),
+        };
         const { result } = renderHook(() => useLazyOperation(executor, testOperation));
         let promise;
         act(() => {
@@ -31,7 +33,9 @@ describe('useLazyOperation', () => {
     });
     it('Should return loading state after invoking, then failure state', async () => {
         const error = new Error('Network error');
-        const executor = async () => { throw error; };
+        const executor = {
+            executeSync: async () => { throw error; },
+        };
         const { result } = renderHook(() => useLazyOperation(executor, testOperation));
         let promise;
         act(() => {

package/tests/useOperation.spec.jsx

@@ -5,10 +5,12 @@ import assert from 'assert';
 import { testOperation } from './utils.js';
 describe('useOperation', () => {
     it('Should return loading state and then success state', async () => {
-        const executor = async () => ({
-            result: { a: 1 },
-            response: new Response()
-        });
+        const executor = {
+            executeSync: async () => ({
+                result: { a: 1 },
+                response: new Response()
+            }),
+        };
         const { result } = renderHook((props) => useOperation(...props), {
             initialProps: [executor, testOperation, {}, {}]
         });
@@ -21,7 +23,9 @@ describe('useOperation', () => {
     });
     it('Should return loading state and then failure state', async () => {
         const error = new Error('Network error');
-        const executor = async () => { throw error; };
+        const executor = {
+            executeSync: async () => { throw error; }
+        };
         const { result } = renderHook((props) => useOperation(...props), {
             initialProps: [executor, testOperation, {}, {}]
         });

package/tests/useSubscription.spec.jsx

@@ -5,20 +5,22 @@ import assert from 'assert';
 import { testSubscription } from './utils.js';
 describe('useSubscription', () => {
     it('Should return loading state and then success state', async () => {
-        const executor = async () => {
-            const readableStream = new ReadableStream();
-            const response = new Response(readableStream);
-            return {
-                result: {
-                    stream: (async function* () {
-                        yield { number: 1 };
-                        yield { number: 2 };
-                        yield { number: 3 };
-                    })(),
-                    close: () => { }
-                },
-                response
-            };
+        const executor = {
+            executeSubscription: async () => {
+                const readableStream = new ReadableStream();
+                const response = new Response(readableStream);
+                return {
+                    result: {
+                        stream: (async function* () {
+                            yield { number: 1 };
+                            yield { number: 2 };
+                            yield { number: 3 };
+                        })(),
+                        close: () => { }
+                    },
+                    response
+                };
+            },
         };
         const { result } = renderHook((props) => useSubscription(...props), {
             initialProps: [executor, testSubscription, {}, {}]
@@ -36,7 +38,9 @@ describe('useSubscription', () => {
     });
     it('Should return loading state and then failure state', async () => {
         const error = new Error('Network error');
-        const executor = async () => { throw error; };
+        const executor = {
+            executeSubscription: async () => { throw error; }
+        };
         const { result } = renderHook((props) => useSubscription(...props), {
             initialProps: [executor, testSubscription, {}, {}]
         });

package/types.d.ts

@@ -22,12 +22,12 @@ export interface ExecuteResult<TResult> {
     result: TResult;
     response: Response;
 }
-export type SubOpAsyncIterable<TResult> = {
+export interface SubOpAsyncIterable<TResult> extends Disposable {
     stream: AsyncIterable<TResult, void, unknown>;
     close: () => void;
-};
-export type Executor<TRequestContext extends RequestContext> = {
-    <TSyncOp extends SyncOperation<unknown, unknown>>(operation: TSyncOp, variables: OperationVariables<TSyncOp>, context: TRequestContext): Promise<ExecuteResult<OperationResult<TSyncOp>>>;
-    <TOperation extends SubscriptionOperation<unknown, unknown>>(operation: TOperation, variables: OperationVariables<TOperation>, context: TRequestContext): Promise<ExecuteResult<SubOpAsyncIterable<OperationResult<TOperation>>>>;
-};
+}
+export interface IExecutor<TRequestContext extends RequestContext> {
+    executeSync<T extends SyncOperation<unknown, unknown>>(operation: T, variables: OperationVariables<T>, requestContext: TRequestContext): Promise<ExecuteResult<OperationResult<T>>>;
+    executeSubscription<T extends SubscriptionOperation<unknown, unknown>>(operation: T, variables: OperationVariables<T>, requestContext: TRequestContext, controller: AbortController): Promise<ExecuteResult<SubOpAsyncIterable<OperationResult<T>>>>;
+}
 export {};

package/use-lazy-operation/hook.d.ts

@@ -0,0 +1,3 @@
+import type { IExecutor, OperationResult, OperationVariables, RequestContext, SyncOperation } from '../types.js';
+import { UseLazyOperationReturnType } from './types.js';
+export declare function useLazyOperation<T extends SyncOperation<unknown, unknown>, TRequestContext extends RequestContext>(executor: IExecutor<TRequestContext>, operation: T): UseLazyOperationReturnType<OperationVariables<T>, OperationResult<T>, TRequestContext>;

package/{useLazyOperation.jsx → use-lazy-operation/hook.js}

@@ -1,10 +1,10 @@
 import { useCallback, useState } from 'react';
-import { loadingState } from './useOperation.jsx';
-export const lazyInitialState = Object.freeze({ state: 'initial' });
+import { loadingState } from '../loading-state.js';
+const lazyInitialState = Object.freeze({ state: 'initial' });
 async function execute(executor, operation, variables, requestContext, setState) {
     let newState;
     try {
-        const result = await executor(operation, variables, requestContext);
+        const result = await executor.executeSync(operation, variables, requestContext);
         newState = { state: 'success', ...result };
     }
     catch (error) {

package/use-lazy-operation/index.d.ts

@@ -0,0 +1,2 @@
+export { useLazyOperation, } from './hook.js';
+export type { LazyOperationInitialState, LazyOperationState, LazyOperationExecuteReturnType, UseLazyOperationReturnType } from './types.js';

package/use-lazy-operation/index.js

@@ -0,0 +1 @@
+export { useLazyOperation, } from './hook.js';

package/use-lazy-operation/types.d.ts

@@ -0,0 +1,14 @@
+import type { RequestContext } from '../types.js';
+import { type OperationFailureState, type OperationState, type OperationSuccessState } from '../useOperation.jsx';
+export interface LazyOperationInitialState {
+    state: 'initial';
+}
+export type LazyOperationState<TResult> = OperationState<TResult> | LazyOperationInitialState;
+export type LazyOperationExecuteReturnType<TResult> = Promise<OperationSuccessState<TResult> | OperationFailureState>;
+export type UseLazyOperationReturnType<TVariables, TResult, TRequestContext extends RequestContext> = [
+    (variables: TVariables, requestContext: TRequestContext) => LazyOperationExecuteReturnType<TResult>,
+    {
+        state: LazyOperationState<TResult>;
+        reset: () => void;
+    }
+];

package/use-lazy-operation/types.js

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

package/useOperation.d.ts

@@ -1,4 +1,4 @@
-import type { ExecuteResult, Executor, OperationResult, OperationVariables, RequestContext, SyncOperation } from './types.js';
+import type { ExecuteResult, IExecutor, OperationResult, OperationVariables, RequestContext, SyncOperation } from './types.js';
 export interface OperationLoadingState {
     state: 'loading';
 }
@@ -10,7 +10,4 @@ export interface OperationFailureState {
     error: Error;
 }
 export type OperationState<TResult> = OperationLoadingState | OperationSuccessState<TResult> | OperationFailureState;
-export declare const loadingState: Readonly<{
-    readonly state: "loading";
-}>;
-export declare function useOperation<T extends SyncOperation<unknown, unknown>, TRequestContext extends RequestContext>(executor: Executor<TRequestContext>, operation: T, variables: OperationVariables<T>, requestContext: TRequestContext): OperationState<OperationResult<T>>;
+export declare function useOperation<T extends SyncOperation<unknown, unknown>, TRequestContext extends RequestContext>(executor: IExecutor<TRequestContext>, operation: T, variables: OperationVariables<T>, requestContext: TRequestContext): OperationState<OperationResult<T>>;

package/useOperation.jsx

@@ -1,12 +1,12 @@
 import { useEffect, useMemo, useState } from 'react';
 import hash from 'object-hash';
-export const loadingState = Object.freeze({ state: 'loading' });
+import { loadingState } from './loading-state.js';
 export function useOperation(executor, operation, variables, requestContext) {
     const [state, setState] = useState(loadingState);
     const memoizedVariables = useMemo(() => variables, [hash(variables)]);
     const memoizedRequestContext = useMemo(() => requestContext, [hash(requestContext)]);
     useEffect(() => {
-        executor(operation, variables, requestContext)
+        executor.executeSync(operation, variables, requestContext)
             .then(result => setState({ state: 'success', ...result }))
             .catch(error => setState({ state: 'failure', error }));
         return () => setState(loadingState);

package/useSubscription.d.ts

@@ -1,3 +1,3 @@
-import type { Executor, OperationResult, OperationVariables, RequestContext, SubOpAsyncIterable, SubscriptionOperation } from './types.js';
+import type { IExecutor, OperationResult, OperationVariables, RequestContext, SubOpAsyncIterable, SubscriptionOperation } from './types.js';
 import { type OperationState } from './useOperation.jsx';
-export declare function useSubscription<T extends SubscriptionOperation<unknown, unknown>, TRequestContext extends RequestContext>(executor: Executor<TRequestContext>, operation: T, variables: OperationVariables<T>, requestContext: TRequestContext): OperationState<SubOpAsyncIterable<OperationResult<T>>>;
+export declare function useSubscription<T extends SubscriptionOperation<unknown, unknown>, TRequestContext extends RequestContext>(executor: IExecutor<TRequestContext>, operation: T, variables: OperationVariables<T>, requestContext: TRequestContext): OperationState<SubOpAsyncIterable<OperationResult<T>>>;

package/useSubscription.jsx

@@ -1,12 +1,12 @@
 import { useEffect, useMemo, useState } from 'react';
 import hash from 'object-hash';
-import { loadingState } from './useOperation.jsx';
+import { loadingState } from './loading-state.js';
 export function useSubscription(executor, operation, variables, requestContext) {
     const [state, setState] = useState(loadingState);
     const memoizedVariables = useMemo(() => variables, [hash(variables)]);
     const memoizedRequestContext = useMemo(() => requestContext, [hash(requestContext)]);
     useEffect(() => {
-        executor(operation, variables, requestContext)
+        executor.executeSubscription(operation, variables, requestContext, new AbortController())
             .then(result => setState({ state: 'success', ...result }))
             .catch(error => setState({ state: 'failure', error }));
         return () => {

package/useLazyOperation.d.ts

@@ -1,19 +0,0 @@
-import type { Executor, OperationResult, OperationVariables, RequestContext, SyncOperation } from './types.js';
-import { type OperationFailureState, type OperationState, type OperationSuccessState } from './useOperation.jsx';
-export interface LazyOperationInitialState {
-    state: 'initial';
-}
-export type LazyOperationState<TResult> = OperationState<TResult> | LazyOperationInitialState;
-export declare const lazyInitialState: Readonly<{
-    readonly state: "initial";
-}>;
-type LazyOperationExecuteReturnType<TResult> = Promise<OperationSuccessState<TResult> | OperationFailureState>;
-export type UseLazyOperationReturnType<TVariables, TResult, TRequestContext extends RequestContext> = [
-    (variables: TVariables, requestContext: TRequestContext) => LazyOperationExecuteReturnType<TResult>,
-    {
-        state: LazyOperationState<TResult>;
-        reset: () => void;
-    }
-];
-export declare function useLazyOperation<T extends SyncOperation<unknown, unknown>, TRequestContext extends RequestContext>(executor: Executor<TRequestContext>, operation: T): UseLazyOperationReturnType<OperationVariables<T>, OperationResult<T>, TRequestContext>;
-export {};