@envelop/core 2.5.1-alpha-20220824165935-4720f031 → 2.6.0

package/cjs/utils.js

@@ -1,7 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.errorAsyncIterator = exports.finalAsyncIterator = exports.handleStreamOrSingleExecutionResult = exports.isAsyncIterable = exports.makeExecute = exports.mapAsyncIterator = exports.makeSubscribe = exports.isIntrospectionOperationString = exports.envelopIsIntrospectionSymbol = void 0;
+exports.errorAsyncIterator = exports.finalAsyncIterator = exports.handleStreamOrSingleExecutionResult = exports.isAsyncIterable = exports.makeExecute = exports.mapAsyncIterator = exports.makeSubscribe = exports.isIntrospectionOperationString = exports.isIntrospectionDocument = exports.isIntrospectionOperation = exports.isOperationDefinition = exports.envelopIsIntrospectionSymbol = void 0;
+const graphql_1 = require("graphql");
 exports.envelopIsIntrospectionSymbol = Symbol('ENVELOP_IS_INTROSPECTION');
+function isOperationDefinition(def) {
+    return def.kind === graphql_1.Kind.OPERATION_DEFINITION;
+}
+exports.isOperationDefinition = isOperationDefinition;
+function isIntrospectionOperation(operation) {
+    return isIntrospectionDocument({
+        kind: graphql_1.Kind.DOCUMENT,
+        definitions: [operation],
+    });
+}
+exports.isIntrospectionOperation = isIntrospectionOperation;
+function isIntrospectionDocument(document) {
+    let isIntrospectionOperation = false;
+    (0, graphql_1.visit)(document, {
+        Field: node => {
+            if (node.name.value === '__schema' || node.name.value === '__type') {
+                isIntrospectionOperation = true;
+                return graphql_1.BREAK;
+            }
+        },
+    });
+    return isIntrospectionOperation;
+}
+exports.isIntrospectionDocument = isIntrospectionDocument;
 function isIntrospectionOperationString(operation) {
     return (typeof operation === 'string' ? operation : operation.body).indexOf('__schema') !== -1;
 }

package/esm/create.js

@@ -1,14 +1,12 @@
 import { isPluginEnabled } from './enable-if.js';
 import { createEnvelopOrchestrator } from './orchestrator.js';
+import { traceOrchestrator } from './traced-orchestrator.js';
 export function envelop(options) {
     const plugins = options.plugins.filter(isPluginEnabled);
-    const orchestrator = createEnvelopOrchestrator({
-        plugins,
-        parse: options.parse,
-        execute: options.execute,
-        validate: options.validate,
-        subscribe: options.subscribe,
-    });
+    let orchestrator = createEnvelopOrchestrator(plugins);
+    if (options.enableInternalTracing) {
+        orchestrator = traceOrchestrator(orchestrator);
+    }
     const getEnveloped = (initialContext = {}) => {
         const typedOrchestrator = orchestrator;
         typedOrchestrator.init(initialContext);

package/esm/index.js

@@ -3,9 +3,11 @@ export * from './create.js';
 export * from './utils.js';
 export * from './plugins/use-envelop.js';
 export * from './plugins/use-logger.js';
+export * from './plugins/use-timing.js';
 export * from './plugins/use-schema.js';
 export * from './plugins/use-error-handler.js';
 export * from './plugins/use-extend-context.js';
 export * from './plugins/use-payload-formatter.js';
+export * from './plugins/use-masked-errors.js';
+export * from './plugins/use-immediate-introspection.js';
 export * from './enable-if.js';
-export { resolversHooksSymbol } from './orchestrator.js';

package/esm/orchestrator.js

@@ -1,6 +1,7 @@
+import { execute, parse, specifiedRules, subscribe, validate, } from 'graphql';
+import { prepareTracedSchema, resolversHooksSymbol } from './traced-schema.js';
 import { errorAsyncIterator, finalAsyncIterator, makeExecute, makeSubscribe, mapAsyncIterator, isAsyncIterable, } from './utils.js';
-export const resolversHooksSymbol = Symbol('RESOLVERS_HOOKS');
-export function createEnvelopOrchestrator({ plugins, parse, execute, subscribe, validate, }) {
+export function createEnvelopOrchestrator(plugins) {
     let schema = null;
     let initDone = false;
     const onResolversHandlers = [];
@@ -14,7 +15,7 @@ export function createEnvelopOrchestrator({ plugins, parse, execute, subscribe,
     // here not to call the same plugin that initiated the schema switch.
     const replaceSchema = (newSchema, ignorePluginIndex = -1) => {
         if (onResolversHandlers.length) {
-            // prepareTracedSchema(newSchema);
+            prepareTracedSchema(newSchema);
         }
         schema = newSchema;
         if (initDone) {
@@ -150,10 +151,7 @@ export function createEnvelopOrchestrator({ plugins, parse, execute, subscribe,
                     validateFn,
                     addValidationRule: rule => {
                         if (!actualRules) {
-                            // Ideally we should provide default validation rules here.
-                            // eslint-disable-next-line no-console
-                            console.warn('No default validation rules provided.');
-                            actualRules = [];
+                            actualRules = [...specifiedRules];
                         }
                         actualRules.push(rule);
                     },
@@ -169,9 +167,6 @@ export function createEnvelopOrchestrator({ plugins, parse, execute, subscribe,
             if (!result) {
                 result = validateFn(schema, documentAST, actualRules, typeInfo, validationOptions);
             }
-            if (!result) {
-                return;
-            }
             const valid = result.length === 0;
             for (const afterCb of afterCalls) {
                 afterCb({
@@ -284,9 +279,6 @@ export function createEnvelopOrchestrator({ plugins, parse, execute, subscribe,
                     // Can be removed once we drop support for GraphQL.js 15
                 });
             }
-            if (!result) {
-                return;
-            }
             const onNextHandler = [];
             const onEndHandler = [];
             for (const afterCb of afterCalls) {

package/esm/plugins/use-immediate-introspection.js

@@ -0,0 +1,46 @@
+import { BREAK } from 'graphql';
+const OnNonIntrospectionFieldReachedValidationRule = (onNonIntrospectionField) => ctx => {
+    const rootQueryType = ctx.getSchema().getQueryType();
+    const rootMutationType = ctx.getSchema().getMutationType();
+    const rootSubscriptionType = ctx.getSchema().getSubscriptionType();
+    return {
+        Field(field) {
+            const parentType = ctx.getParentType();
+            const isQuery = parentType === rootQueryType;
+            const isMutation = parentType === rootMutationType;
+            const isSubscription = parentType === rootSubscriptionType;
+            if ((isQuery && !field.name.value.startsWith('__')) || isMutation || isSubscription) {
+                onNonIntrospectionField();
+                return BREAK;
+            }
+            return undefined;
+        },
+    };
+};
+const fastIntroSpectionSymbol = Symbol('fastIntrospection');
+/**
+ * In case a GraphQL operation only contains introspection fields the context building can be skipped completely.
+ * With this plugin any further context extensions will be skipped.
+ */
+export const useImmediateIntrospection = () => {
+    return {
+        onValidate({ addValidationRule }) {
+            let isIntrospectionOnly = true;
+            addValidationRule(OnNonIntrospectionFieldReachedValidationRule(() => {
+                isIntrospectionOnly = false;
+            }));
+            return function afterValidate({ extendContext }) {
+                if (isIntrospectionOnly) {
+                    extendContext({ [fastIntroSpectionSymbol]: true });
+                }
+            };
+        },
+        onContextBuilding({ context, breakContextBuilding }) {
+            if (context[fastIntroSpectionSymbol]) {
+                // hijack and skip all other context related stuff.
+                // We dont need a context!
+                breakContextBuilding();
+            }
+        },
+    };
+};

package/esm/plugins/use-masked-errors.js

@@ -0,0 +1,87 @@
+import { GraphQLError } from 'graphql';
+import { handleStreamOrSingleExecutionResult } from '../utils.js';
+export const DEFAULT_ERROR_MESSAGE = 'Unexpected error.';
+export class EnvelopError extends GraphQLError {
+    constructor(message, extensions) {
+        super(message, undefined, undefined, undefined, undefined, undefined, extensions);
+    }
+}
+export const formatError = (err, message, isDev) => {
+    var _a, _b, _c, _d;
+    if (err instanceof GraphQLError) {
+        if (
+        /** execution error */
+        (err.originalError && err.originalError instanceof EnvelopError === false) ||
+            /** validate and parse errors */
+            (err.originalError === undefined && err instanceof EnvelopError === false)) {
+            return new GraphQLError(message, err.nodes, err.source, err.positions, err.path, undefined, isDev
+                ? {
+                    originalError: {
+                        message: (_b = (_a = err.originalError) === null || _a === void 0 ? void 0 : _a.message) !== null && _b !== void 0 ? _b : err.message,
+                        stack: (_d = (_c = err.originalError) === null || _c === void 0 ? void 0 : _c.stack) !== null && _d !== void 0 ? _d : err.stack,
+                    },
+                }
+                : undefined);
+        }
+        return err;
+    }
+    return new GraphQLError(message);
+};
+const makeHandleResult = (format, message, isDev) => ({ result, setResult }) => {
+    if (result.errors != null) {
+        setResult({ ...result, errors: result.errors.map(error => format(error, message, isDev)) });
+    }
+};
+export const useMaskedErrors = (opts) => {
+    var _a, _b;
+    const format = (_a = opts === null || opts === void 0 ? void 0 : opts.formatError) !== null && _a !== void 0 ? _a : formatError;
+    const message = (opts === null || opts === void 0 ? void 0 : opts.errorMessage) || DEFAULT_ERROR_MESSAGE;
+    // eslint-disable-next-line dot-notation
+    const isDev = (_b = opts === null || opts === void 0 ? void 0 : opts.isDev) !== null && _b !== void 0 ? _b : (typeof process !== 'undefined' ? process.env['NODE_ENV'] === 'development' : false);
+    const handleResult = makeHandleResult(format, message, isDev);
+    return {
+        onParse: (opts === null || opts === void 0 ? void 0 : opts.handleParseErrors) === true
+            ? function onParse() {
+                return function onParseEnd({ result, replaceParseResult }) {
+                    if (result instanceof Error) {
+                        replaceParseResult(format(result, message, isDev));
+                    }
+                };
+            }
+            : undefined,
+        onValidate: (opts === null || opts === void 0 ? void 0 : opts.handleValidationErrors) === true
+            ? function onValidate() {
+                return function onValidateEnd({ valid, result, setResult }) {
+                    if (valid === false) {
+                        setResult(result.map(error => format(error, message, isDev)));
+                    }
+                };
+            }
+            : undefined,
+        onPluginInit(context) {
+            context.registerContextErrorHandler(({ error, setError }) => {
+                if (error instanceof GraphQLError === false && error instanceof Error) {
+                    error = new GraphQLError(error.message, undefined, undefined, undefined, undefined, error);
+                }
+                setError(format(error, message, isDev));
+            });
+        },
+        onExecute() {
+            return {
+                onExecuteDone(payload) {
+                    return handleStreamOrSingleExecutionResult(payload, handleResult);
+                },
+            };
+        },
+        onSubscribe() {
+            return {
+                onSubscribeResult(payload) {
+                    return handleStreamOrSingleExecutionResult(payload, handleResult);
+                },
+                onSubscribeError({ error, setError }) {
+                    setError(format(error, message, isDev));
+                },
+            };
+        },
+    };
+};

package/esm/plugins/use-timing.js

@@ -0,0 +1,134 @@
+import { getOperationAST } from 'graphql';
+import { isIntrospectionOperationString, envelopIsIntrospectionSymbol } from '../utils.js';
+const HR_TO_NS = 1e9;
+const NS_TO_MS = 1e6;
+const DEFAULT_OPTIONS = {
+    onExecutionMeasurement: (args, timing) => console.log(`Operation execution "${args.operationName}" done in ${timing.ms}ms`),
+    onSubscriptionMeasurement: (args, timing) => console.log(`Operation subscription "${args.operationName}" done in ${timing.ms}ms`),
+    onParsingMeasurement: (source, timing) => console.log(`Parsing "${source}" done in ${timing.ms}ms`),
+    onValidationMeasurement: (document, timing) => { var _a, _b; return console.log(`Validation "${((_b = (_a = getOperationAST(document)) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.value) || '-'}" done in ${timing.ms}ms`); },
+    onResolverMeasurement: (info, timing) => console.log(`\tResolver of "${info.parentType.toString()}.${info.fieldName}" done in ${timing.ms}ms`),
+    onContextBuildingMeasurement: (timing) => console.log(`Context building done in ${timing.ms}ms`),
+};
+const deltaFrom = (hrtime) => {
+    const delta = process.hrtime(hrtime);
+    const ns = delta[0] * HR_TO_NS + delta[1];
+    return {
+        ns,
+        get ms() {
+            return ns / NS_TO_MS;
+        },
+    };
+};
+export const useTiming = (rawOptions) => {
+    const options = {
+        ...DEFAULT_OPTIONS,
+        ...rawOptions,
+    };
+    const result = {};
+    if (options.onContextBuildingMeasurement) {
+        result.onContextBuilding = ({ context }) => {
+            if (context[envelopIsIntrospectionSymbol]) {
+                return;
+            }
+            const contextStartTime = process.hrtime();
+            return () => {
+                options.onContextBuildingMeasurement(deltaFrom(contextStartTime));
+            };
+        };
+    }
+    if (options.onParsingMeasurement) {
+        result.onParse = ({ params, extendContext }) => {
+            if (options.skipIntrospection && isIntrospectionOperationString(params.source)) {
+                extendContext({
+                    [envelopIsIntrospectionSymbol]: true,
+                });
+                return;
+            }
+            const parseStartTime = process.hrtime();
+            return () => {
+                options.onParsingMeasurement(params.source, deltaFrom(parseStartTime));
+            };
+        };
+    }
+    if (options.onValidationMeasurement) {
+        result.onValidate = ({ params, context }) => {
+            if (context[envelopIsIntrospectionSymbol]) {
+                return;
+            }
+            const validateStartTime = process.hrtime();
+            return () => {
+                options.onValidationMeasurement(params.documentAST, deltaFrom(validateStartTime));
+            };
+        };
+    }
+    if (options.onExecutionMeasurement) {
+        if (options.onResolverMeasurement) {
+            result.onExecute = ({ args }) => {
+                if (args.contextValue[envelopIsIntrospectionSymbol]) {
+                    return;
+                }
+                const executeStartTime = process.hrtime();
+                return {
+                    onExecuteDone: () => {
+                        options.onExecutionMeasurement(args, deltaFrom(executeStartTime));
+                    },
+                };
+            };
+            result.onResolverCalled = ({ info }) => {
+                const resolverStartTime = process.hrtime();
+                return () => {
+                    options.onResolverMeasurement(info, deltaFrom(resolverStartTime));
+                };
+            };
+        }
+        else {
+            result.onExecute = ({ args }) => {
+                if (args.contextValue[envelopIsIntrospectionSymbol]) {
+                    return;
+                }
+                const executeStartTime = process.hrtime();
+                return {
+                    onExecuteDone: () => {
+                        options.onExecutionMeasurement(args, deltaFrom(executeStartTime));
+                    },
+                };
+            };
+        }
+    }
+    if (options.onSubscriptionMeasurement) {
+        if (options.onResolverMeasurement) {
+            result.onSubscribe = ({ args }) => {
+                if (args.contextValue[envelopIsIntrospectionSymbol]) {
+                    return;
+                }
+                const subscribeStartTime = process.hrtime();
+                return {
+                    onSubscribeResult: () => {
+                        options.onSubscriptionMeasurement && options.onSubscriptionMeasurement(args, deltaFrom(subscribeStartTime));
+                    },
+                };
+            };
+            result.onResolverCalled = ({ info }) => {
+                const resolverStartTime = process.hrtime();
+                return () => {
+                    options.onResolverMeasurement && options.onResolverMeasurement(info, deltaFrom(resolverStartTime));
+                };
+            };
+        }
+        else {
+            result.onSubscribe = ({ args }) => {
+                if (args.contextValue[envelopIsIntrospectionSymbol]) {
+                    return;
+                }
+                const subscribeStartTime = process.hrtime();
+                return {
+                    onSubscribeResult: () => {
+                        options.onSubscriptionMeasurement && options.onSubscriptionMeasurement(args, deltaFrom(subscribeStartTime));
+                    },
+                };
+            };
+        }
+    }
+    return result;
+};

package/esm/traced-orchestrator.js

@@ -0,0 +1,132 @@
+var _a;
+import { GraphQLSchema, } from 'graphql';
+import { isAsyncIterable } from './utils.js';
+const getTimestamp = typeof globalThis !== 'undefined' && ((_a = globalThis === null || globalThis === void 0 ? void 0 : globalThis.performance) === null || _a === void 0 ? void 0 : _a.now)
+    ? () => globalThis.performance.now()
+    : () => Date.now();
+const measure = () => {
+    const start = getTimestamp();
+    return () => {
+        const end = getTimestamp();
+        return end - start;
+    };
+};
+const tracingSymbol = Symbol('envelopTracing');
+export function traceOrchestrator(orchestrator) {
+    const createTracer = (name, ctx) => {
+        const end = measure();
+        return () => {
+            ctx[tracingSymbol][name] = end();
+        };
+    };
+    return {
+        ...orchestrator,
+        init: (ctx = {}) => {
+            ctx[tracingSymbol] = ctx[tracingSymbol] || {};
+            const done = createTracer('init', ctx || {});
+            try {
+                return orchestrator.init(ctx);
+            }
+            finally {
+                done();
+            }
+        },
+        parse: (ctx = {}) => {
+            ctx[tracingSymbol] = ctx[tracingSymbol] || {};
+            const actualFn = orchestrator.parse(ctx);
+            return (...args) => {
+                const done = createTracer('parse', ctx);
+                try {
+                    return actualFn(...args);
+                }
+                finally {
+                    done();
+                }
+            };
+        },
+        validate: (ctx = {}) => {
+            ctx[tracingSymbol] = ctx[tracingSymbol] || {};
+            const actualFn = orchestrator.validate(ctx);
+            return (...args) => {
+                const done = createTracer('validate', ctx);
+                try {
+                    return actualFn(...args);
+                }
+                finally {
+                    done();
+                }
+            };
+        },
+        execute: async (argsOrSchema, document, rootValue, contextValue, variableValues, operationName, fieldResolver, typeResolver) => {
+            const args = argsOrSchema instanceof GraphQLSchema
+                ? {
+                    schema: argsOrSchema,
+                    document: document,
+                    rootValue,
+                    contextValue,
+                    variableValues,
+                    operationName,
+                    fieldResolver,
+                    typeResolver,
+                }
+                : argsOrSchema;
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore GraphQL.js types contextValue as unknown
+            const done = createTracer('execute', args.contextValue || {});
+            try {
+                const result = await orchestrator.execute(args);
+                done();
+                if (!isAsyncIterable(result)) {
+                    result.extensions = result.extensions || {};
+                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                    // @ts-ignore GraphQL.js types contextValue as unknown
+                    result.extensions.envelopTracing = args.contextValue[tracingSymbol];
+                }
+                else {
+                    // eslint-disable-next-line no-console
+                    console.warn(`"traceOrchestrator" encountered a AsyncIterator which is not supported yet, so tracing data is not available for the operation.`);
+                }
+                return result;
+            }
+            catch (e) {
+                done();
+                throw e;
+            }
+        },
+        subscribe: async (argsOrSchema, document, rootValue, contextValue, variableValues, operationName, fieldResolver, subscribeFieldResolver) => {
+            const args = argsOrSchema instanceof GraphQLSchema
+                ? {
+                    schema: argsOrSchema,
+                    document: document,
+                    rootValue,
+                    contextValue,
+                    variableValues,
+                    operationName,
+                    fieldResolver,
+                    subscribeFieldResolver,
+                }
+                : argsOrSchema;
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore GraphQL.js types contextValue as unknown
+            const done = createTracer('subscribe', args.contextValue || {});
+            try {
+                return await orchestrator.subscribe(args);
+            }
+            finally {
+                done();
+            }
+        },
+        contextFactory: (ctx = {}) => {
+            const actualFn = orchestrator.contextFactory(ctx);
+            return async (childCtx) => {
+                const done = createTracer('contextFactory', ctx);
+                try {
+                    return await actualFn(childCtx);
+                }
+                finally {
+                    done();
+                }
+            };
+        },
+    };
+}

package/esm/traced-schema.js

@@ -0,0 +1,64 @@
+import { defaultFieldResolver, isIntrospectionType, isObjectType } from 'graphql';
+export const trackedSchemaSymbol = Symbol('TRACKED_SCHEMA');
+export const resolversHooksSymbol = Symbol('RESOLVERS_HOOKS');
+export function prepareTracedSchema(schema) {
+    if (!schema || schema[trackedSchemaSymbol]) {
+        return;
+    }
+    schema[trackedSchemaSymbol] = true;
+    const entries = Object.values(schema.getTypeMap());
+    for (const type of entries) {
+        if (!isIntrospectionType(type) && isObjectType(type)) {
+            const fields = Object.values(type.getFields());
+            for (const field of fields) {
+                let resolverFn = (field.resolve || defaultFieldResolver);
+                field.resolve = async (root, args, context, info) => {
+                    if (context && context[resolversHooksSymbol]) {
+                        const hooks = context[resolversHooksSymbol];
+                        const afterCalls = [];
+                        for (const hook of hooks) {
+                            const afterFn = await hook({
+                                root,
+                                args,
+                                context,
+                                info,
+                                resolverFn,
+                                replaceResolverFn: newFn => {
+                                    resolverFn = newFn;
+                                },
+                            });
+                            afterFn && afterCalls.push(afterFn);
+                        }
+                        try {
+                            let result = await resolverFn(root, args, context, info);
+                            for (const afterFn of afterCalls) {
+                                afterFn({
+                                    result,
+                                    setResult: newResult => {
+                                        result = newResult;
+                                    },
+                                });
+                            }
+                            return result;
+                        }
+                        catch (e) {
+                            let resultErr = e;
+                            for (const afterFn of afterCalls) {
+                                afterFn({
+                                    result: resultErr,
+                                    setResult: newResult => {
+                                        resultErr = newResult;
+                                    },
+                                });
+                            }
+                            throw resultErr;
+                        }
+                    }
+                    else {
+                        return resolverFn(root, args, context, info);
+                    }
+                };
+            }
+        }
+    }
+}

package/esm/utils.js

@@ -1,4 +1,26 @@
+import { Kind, visit, BREAK, } from 'graphql';
 export const envelopIsIntrospectionSymbol = Symbol('ENVELOP_IS_INTROSPECTION');
+export function isOperationDefinition(def) {
+    return def.kind === Kind.OPERATION_DEFINITION;
+}
+export function isIntrospectionOperation(operation) {
+    return isIntrospectionDocument({
+        kind: Kind.DOCUMENT,
+        definitions: [operation],
+    });
+}
+export function isIntrospectionDocument(document) {
+    let isIntrospectionOperation = false;
+    visit(document, {
+        Field: node => {
+            if (node.name.value === '__schema' || node.name.value === '__type') {
+                isIntrospectionOperation = true;
+                return BREAK;
+            }
+        },
+    });
+    return isIntrospectionOperation;
+}
 export function isIntrospectionOperationString(operation) {
     return (typeof operation === 'string' ? operation : operation.body).indexOf('__schema') !== -1;
 }

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "@envelop/core",
-  "version": "2.5.1-alpha-20220824165935-4720f031",
+  "version": "2.6.0",
   "sideEffects": false,
+  "peerDependencies": {
+    "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0"
+  },
   "dependencies": {
-    "@envelop/types": "2.3.2-alpha-20220824165935-4720f031"
+    "@envelop/types": "2.4.0",
+    "tslib": "2.4.0"
   },
   "repository": {
     "type": "git",

package/typings/create.d.cts

@@ -1,10 +1,6 @@
-import { GetEnvelopedFn, ComposeContext, Plugin, ExecuteFunction, SubscribeFunction, ParseFunction, ValidateFunction } from '@envelop/types';
+import { GetEnvelopedFn, ComposeContext, Plugin } from '@envelop/types';
 import { PluginOrDisabledPlugin } from './enable-if.cjs';
 export declare function envelop<PluginsType extends Plugin<any>[]>(options: {
     plugins: Array<PluginOrDisabledPlugin>;
     enableInternalTracing?: boolean;
-    parse: ParseFunction;
-    execute: ExecuteFunction;
-    validate: ValidateFunction;
-    subscribe: SubscribeFunction;
 }): GetEnvelopedFn<ComposeContext<PluginsType>>;

package/typings/create.d.ts

@@ -1,10 +1,6 @@
-import { GetEnvelopedFn, ComposeContext, Plugin, ExecuteFunction, SubscribeFunction, ParseFunction, ValidateFunction } from '@envelop/types';
+import { GetEnvelopedFn, ComposeContext, Plugin } from '@envelop/types';
 import { PluginOrDisabledPlugin } from './enable-if.js';
 export declare function envelop<PluginsType extends Plugin<any>[]>(options: {
     plugins: Array<PluginOrDisabledPlugin>;
     enableInternalTracing?: boolean;
-    parse: ParseFunction;
-    execute: ExecuteFunction;
-    validate: ValidateFunction;
-    subscribe: SubscribeFunction;
 }): GetEnvelopedFn<ComposeContext<PluginsType>>;

package/typings/enable-if.d.cts

@@ -10,5 +10,5 @@ export declare function isPluginEnabled(t: PluginOrDisabledPlugin): t is Plugin;
 /**
  * Utility function to enable a plugin.
  */
-export declare function enableIf<PluginContextType = {}>(condition: boolean, plugin: Plugin<PluginContextType> | (() => Plugin<PluginContextType>)): PluginOrDisabledPlugin;
+export declare function enableIf<PluginContextType extends Record<any, any> = {}>(condition: boolean, plugin: Plugin<PluginContextType> | (() => Plugin<PluginContextType>)): PluginOrDisabledPlugin;
 export {};

package/typings/enable-if.d.ts

@@ -10,5 +10,5 @@ export declare function isPluginEnabled(t: PluginOrDisabledPlugin): t is Plugin;
 /**
  * Utility function to enable a plugin.
  */
-export declare function enableIf<PluginContextType = {}>(condition: boolean, plugin: Plugin<PluginContextType> | (() => Plugin<PluginContextType>)): PluginOrDisabledPlugin;
+export declare function enableIf<PluginContextType extends Record<any, any> = {}>(condition: boolean, plugin: Plugin<PluginContextType> | (() => Plugin<PluginContextType>)): PluginOrDisabledPlugin;
 export {};