import './global-types.js'; import SchemaBuilder, { BasePlugin, type BuildCache, type FieldRef, type PothosOutputFieldConfig, type SchemaTypes, } from '@pothos/core'; import { defaultFieldResolver, type GraphQLFieldResolver, type GraphQLTypeResolver } from 'graphql'; import SubscriptionCache from './cache.js'; import { getFieldSubscribe } from './create-field-data.js'; import SubscriptionManager from './manager/index.js'; import resolveWithCache from './resolve-with-cache.js'; const DEFAULT_DEBOUNCE_DELAY = 10; export * from './types.js'; export * from './utils.js'; const pluginName = 'smartSubscriptions'; export default pluginName; export class PothosSmartSubscriptionsPlugin extends BasePlugin< Types, { cache?: SubscriptionCache; } > { debounceDelay: number | null; smartSubscriptionsToQueryField = new Map< string, Extract, { kind: 'Query' }> >(); subscribe: ( name: string, context: Types['Context'], cb: (err: unknown, data: unknown) => void, ) => Promise | void; unsubscribe: (name: string, context: Types['Context']) => Promise | void; constructor(buildCache: BuildCache) { super(buildCache, pluginName); this.subscribe = this.builder.options.smartSubscriptions.subscribe; this.unsubscribe = this.builder.options.smartSubscriptions.unsubscribe; this.debounceDelay = this.builder.options.smartSubscriptions.debounceDelay === null ? null : DEFAULT_DEBOUNCE_DELAY; } override onOutputFieldConfig(fieldConfig: PothosOutputFieldConfig) { if (fieldConfig.kind === 'Query' && fieldConfig.pothosOptions.smartSubscription) { this.smartSubscriptionsToQueryField.set(fieldConfig.name, fieldConfig); this.runUnique(`Subscription.${fieldConfig.name}`, () => { this.builder.subscriptionField( fieldConfig.name, (t) => t.field({ ...fieldConfig.pothosOptions, resolve: (parent, args, context, info) => (fieldConfig.resolve ?? defaultFieldResolver)(parent, args, context, info) as never, subscribe: (parent, _args, context) => { const manager = new SubscriptionManager({ value: parent, debounceDelay: this.debounceDelay, subscribe: (subName, cb) => this.subscribe(subName, context, cb), unsubscribe: (subName) => this.unsubscribe(subName, context), }); const cache = new SubscriptionCache(manager, this.buildCache); this.requestData(context).cache = cache; return { [Symbol.asyncIterator]() { return { async next() { return await manager.next().then((next) => { cache.next(); return next; }); }, async return() { return await manager.return(); }, async throw(error: unknown) { return await manager.throw(error); }, }; }, }; }, }) as FieldRef, ); }); } return fieldConfig; } override createRequestData(_context: Types['Context']) { return {}; } override wrapResolve( resolve: GraphQLFieldResolver, field: PothosOutputFieldConfig, ): GraphQLFieldResolver { let canRefetch = false; if ( field.graphqlKind === 'Object' && field.kind !== 'Query' && field.kind !== 'Subscription' && field.kind !== 'Mutation' ) { canRefetch = field.pothosOptions.canRefetch ?? false; } const subscribe = getFieldSubscribe(field, this); return (parent, args, context, info) => { const { cache } = this.requestData(context); if (!cache) { return resolve(parent, args, context, info); } return resolveWithCache( cache, subscribe, resolve, canRefetch, parent, args as {}, context, info, ); }; } override wrapResolveType(resolveType: GraphQLTypeResolver) { return resolveType; } } SchemaBuilder.registerPlugin(pluginName, PothosSmartSubscriptionsPlugin); export { default as SubscriptionCache } from './cache.js'; export { default as CacheNode } from './cache-node.js'; export { default as BaseSubscriptionManager } from './manager/base.js'; export { default as FieldSubscriptionManager } from './manager/field.js'; export { default as SubscriptionManager } from './manager/index.js'; export { default as TypeSubscriptionManager } from './manager/type.js';