@envelop/core 1.6.4 → 1.6.6-alpha-63e92f8.0

package/index.js

@@ -135,10 +135,50 @@ function getSubscribeArgs(args) {
  * Utility function for making a subscribe function that handles polymorphic arguments.
  */
 const makeSubscribe = (subscribeFn) => ((...polyArgs) => subscribeFn(getSubscribeArgs(polyArgs)));
-async function* mapAsyncIterator(asyncIterable, map) {
-    for await (const value of asyncIterable) {
-        yield map(value);
+function mapAsyncIterator(source, mapper) {
+    const iterator = source[Symbol.asyncIterator]();
+    async function mapResult(result) {
+        var _a;
+        if (result.done) {
+            return result;
+        }
+        try {
+            return { value: await mapper(result.value), done: false };
+        }
+        catch (error) {
+            try {
+                await ((_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator));
+            }
+            catch (_error) {
+                /* ignore error */
+            }
+            throw error;
+        }
     }
+    const stream = {
+        [Symbol.asyncIterator]() {
+            return stream;
+        },
+        async next() {
+            return await mapResult(await iterator.next());
+        },
+        async return() {
+            var _a;
+            const promise = (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
+            return promise ? await mapResult(await promise) : { value: undefined, done: true };
+        },
+        async throw(error) {
+            var _a;
+            const promise = (_a = iterator.throw) === null || _a === void 0 ? void 0 : _a.call(iterator);
+            if (promise) {
+                return await mapResult(await promise);
+            }
+            // if the source has no throw method we just re-throw error
+            // usually throw is not called anyways
+            throw error;
+        },
+    };
+    return stream;
 }
 function getExecuteArgs(args) {
     return args.length === 1
@@ -189,21 +229,75 @@ function handleStreamOrSingleExecutionResult(payload, fn) {
         return undefined;
     }
 }
-async function* finalAsyncIterator(asyncIterable, onFinal) {
-    try {
-        yield* asyncIterable;
-    }
-    finally {
-        onFinal();
-    }
+function finalAsyncIterator(source, onFinal) {
+    const iterator = source[Symbol.asyncIterator]();
+    let isDone = false;
+    const stream = {
+        [Symbol.asyncIterator]() {
+            return stream;
+        },
+        async next() {
+            const result = await iterator.next();
+            if (result.done && isDone === false) {
+                isDone = true;
+                onFinal();
+            }
+            return result;
+        },
+        async return() {
+            var _a;
+            const promise = (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
+            if (isDone === false) {
+                isDone = true;
+                onFinal();
+            }
+            return promise ? await promise : { done: true, value: undefined };
+        },
+        async throw(error) {
+            var _a;
+            const promise = (_a = iterator.throw) === null || _a === void 0 ? void 0 : _a.call(iterator);
+            if (promise) {
+                return await promise;
+            }
+            // if the source has no throw method we just re-throw error
+            // usually throw is not called anyways
+            throw error;
+        },
+    };
+    return stream;
 }
-async function* errorAsyncIterator(asyncIterable, onError) {
-    try {
-        yield* asyncIterable;
-    }
-    catch (err) {
-        onError(err);
-    }
+function errorAsyncIterator(source, onError) {
+    const iterator = source[Symbol.asyncIterator]();
+    const stream = {
+        [Symbol.asyncIterator]() {
+            return stream;
+        },
+        async next() {
+            try {
+                return await iterator.next();
+            }
+            catch (error) {
+                onError(error);
+                return { done: true, value: undefined };
+            }
+        },
+        async return() {
+            var _a;
+            const promise = (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
+            return promise ? await promise : { done: true, value: undefined };
+        },
+        async throw(error) {
+            var _a;
+            const promise = (_a = iterator.throw) === null || _a === void 0 ? void 0 : _a.call(iterator);
+            if (promise) {
+                return await promise;
+            }
+            // if the source has no throw method we just re-throw error
+            // usually throw is not called anyways
+            throw error;
+        },
+    };
+    return stream;
 }
 
 function createEnvelopOrchestrator(plugins) {
@@ -1010,8 +1104,8 @@ const useExtendContext = (contextFactory) => ({
     },
 });
 
-const makeHandleResult$1 = (formatter) => ({ result, setResult }) => {
-    const modified = formatter(result);
+const makeHandleResult$1 = (formatter) => ({ args, result, setResult, }) => {
+    const modified = formatter(result, args);
     if (modified !== false) {
         setResult(modified);
     }

package/index.mjs

@@ -131,10 +131,50 @@ function getSubscribeArgs(args) {
  * Utility function for making a subscribe function that handles polymorphic arguments.
  */
 const makeSubscribe = (subscribeFn) => ((...polyArgs) => subscribeFn(getSubscribeArgs(polyArgs)));
-async function* mapAsyncIterator(asyncIterable, map) {
-    for await (const value of asyncIterable) {
-        yield map(value);
+function mapAsyncIterator(source, mapper) {
+    const iterator = source[Symbol.asyncIterator]();
+    async function mapResult(result) {
+        var _a;
+        if (result.done) {
+            return result;
+        }
+        try {
+            return { value: await mapper(result.value), done: false };
+        }
+        catch (error) {
+            try {
+                await ((_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator));
+            }
+            catch (_error) {
+                /* ignore error */
+            }
+            throw error;
+        }
     }
+    const stream = {
+        [Symbol.asyncIterator]() {
+            return stream;
+        },
+        async next() {
+            return await mapResult(await iterator.next());
+        },
+        async return() {
+            var _a;
+            const promise = (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
+            return promise ? await mapResult(await promise) : { value: undefined, done: true };
+        },
+        async throw(error) {
+            var _a;
+            const promise = (_a = iterator.throw) === null || _a === void 0 ? void 0 : _a.call(iterator);
+            if (promise) {
+                return await mapResult(await promise);
+            }
+            // if the source has no throw method we just re-throw error
+            // usually throw is not called anyways
+            throw error;
+        },
+    };
+    return stream;
 }
 function getExecuteArgs(args) {
     return args.length === 1
@@ -185,21 +225,75 @@ function handleStreamOrSingleExecutionResult(payload, fn) {
         return undefined;
     }
 }
-async function* finalAsyncIterator(asyncIterable, onFinal) {
-    try {
-        yield* asyncIterable;
-    }
-    finally {
-        onFinal();
-    }
+function finalAsyncIterator(source, onFinal) {
+    const iterator = source[Symbol.asyncIterator]();
+    let isDone = false;
+    const stream = {
+        [Symbol.asyncIterator]() {
+            return stream;
+        },
+        async next() {
+            const result = await iterator.next();
+            if (result.done && isDone === false) {
+                isDone = true;
+                onFinal();
+            }
+            return result;
+        },
+        async return() {
+            var _a;
+            const promise = (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
+            if (isDone === false) {
+                isDone = true;
+                onFinal();
+            }
+            return promise ? await promise : { done: true, value: undefined };
+        },
+        async throw(error) {
+            var _a;
+            const promise = (_a = iterator.throw) === null || _a === void 0 ? void 0 : _a.call(iterator);
+            if (promise) {
+                return await promise;
+            }
+            // if the source has no throw method we just re-throw error
+            // usually throw is not called anyways
+            throw error;
+        },
+    };
+    return stream;
 }
-async function* errorAsyncIterator(asyncIterable, onError) {
-    try {
-        yield* asyncIterable;
-    }
-    catch (err) {
-        onError(err);
-    }
+function errorAsyncIterator(source, onError) {
+    const iterator = source[Symbol.asyncIterator]();
+    const stream = {
+        [Symbol.asyncIterator]() {
+            return stream;
+        },
+        async next() {
+            try {
+                return await iterator.next();
+            }
+            catch (error) {
+                onError(error);
+                return { done: true, value: undefined };
+            }
+        },
+        async return() {
+            var _a;
+            const promise = (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
+            return promise ? await promise : { done: true, value: undefined };
+        },
+        async throw(error) {
+            var _a;
+            const promise = (_a = iterator.throw) === null || _a === void 0 ? void 0 : _a.call(iterator);
+            if (promise) {
+                return await promise;
+            }
+            // if the source has no throw method we just re-throw error
+            // usually throw is not called anyways
+            throw error;
+        },
+    };
+    return stream;
 }
 
 function createEnvelopOrchestrator(plugins) {
@@ -1006,8 +1100,8 @@ const useExtendContext = (contextFactory) => ({
     },
 });
 
-const makeHandleResult$1 = (formatter) => ({ result, setResult }) => {
-    const modified = formatter(result);
+const makeHandleResult$1 = (formatter) => ({ args, result, setResult, }) => {
+    const modified = formatter(result, args);
     if (modified !== false) {
         setResult(modified);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@envelop/core",
-  "version": "1.6.4",
+  "version": "1.6.6-alpha-63e92f8.0",
   "sideEffects": false,
   "peerDependencies": {
     "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0"
@@ -38,6 +38,7 @@
     "./*": {
       "require": "./*.js",
       "import": "./*.mjs"
-    }
+    },
+    "./package.json": "./package.json"
   }
 }

package/plugins/use-extend-context.d.ts

@@ -1,5 +1,5 @@
 import { Plugin } from '@envelop/types';
-export declare type ContextFactoryFn<TResult = unknown> = (currentContext: unknown) => TResult | Promise<TResult>;
+export declare type ContextFactoryFn<TResult = unknown, TCurrent = unknown> = (currentContext: TCurrent) => TResult | Promise<TResult>;
 declare type UnwrapAsync<T> = T extends Promise<infer U> ? U : T;
 export declare const useExtendContext: <TContextFactory extends (...args: any[]) => any>(contextFactory: TContextFactory) => Plugin<UnwrapAsync<ReturnType<TContextFactory>>>;
 export {};

package/plugins/use-payload-formatter.d.ts

@@ -1,4 +1,4 @@
-import { Plugin } from '@envelop/types';
+import { Plugin, TypedExecutionArgs } from '@envelop/types';
 import { ExecutionResult } from 'graphql';
-export declare type FormatterFunction = (result: ExecutionResult<any, any>) => false | ExecutionResult<any, any>;
+export declare type FormatterFunction = (result: ExecutionResult<any, any>, args: TypedExecutionArgs<any>) => false | ExecutionResult<any, any>;
 export declare const usePayloadFormatter: (formatter: FormatterFunction) => Plugin;

package/utils.d.ts

@@ -9,7 +9,7 @@ export declare function isIntrospectionOperationString(operation: string | Sourc
  * Utility function for making a subscribe function that handles polymorphic arguments.
  */
 export declare const makeSubscribe: (subscribeFn: (args: SubscriptionArgs) => PromiseOrValue<AsyncIterableIterator<ExecutionResult>>) => SubscribeFunction;
-export declare function mapAsyncIterator<TInput, TOutput = TInput>(asyncIterable: AsyncIterable<TInput>, map: (input: TInput) => Promise<TOutput> | TOutput): AsyncIterableIterator<TOutput>;
+export declare function mapAsyncIterator<T, O>(source: AsyncIterable<T>, mapper: (input: T) => Promise<O> | O): AsyncGenerator<O>;
 /**
  * Utility function for making a execute function that handles polymorphic arguments.
  */
@@ -29,5 +29,5 @@ export declare function isAsyncIterable<TType>(maybeAsyncIterable: unknown): may
  * @returns a subscription for streamed results, or undefined in case of an non-async
  */
 export declare function handleStreamOrSingleExecutionResult<ContextType = DefaultContext>(payload: OnExecuteDoneEventPayload<ContextType>, fn: OnExecuteDoneHookResultOnNextHook<ContextType>): void | OnExecuteDoneHookResult<ContextType>;
-export declare function finalAsyncIterator<TInput>(asyncIterable: AsyncIterable<TInput>, onFinal: () => void): AsyncIterableIterator<TInput>;
-export declare function errorAsyncIterator<TInput>(asyncIterable: AsyncIterable<TInput>, onError: (err: unknown) => void): AsyncIterableIterator<TInput>;
+export declare function finalAsyncIterator<TInput>(source: AsyncIterable<TInput>, onFinal: () => void): AsyncGenerator<TInput>;
+export declare function errorAsyncIterator<TInput>(source: AsyncIterable<TInput>, onError: (err: unknown) => void): AsyncGenerator<TInput>;