@pothos/plugin-federation/esm/index.js

A Pothos plugin for implementing apollo federation subGraphs

import './global-types.js';
import './schema-builder.js';
import SchemaBuilder, { BasePlugin } from '@pothos/core';
import { defaultFieldResolver } from 'graphql';
import { providesMap } from './external-ref.js';
import { addUsedDirectives, entityMapping, keyDirective, mergeDirectives } from './util.js';
export { hasResolvableKey } from './schema-builder.js';
export * from './types.js';
const pluginName = "federation";
export default pluginName;
export class PothosFederationPlugin extends BasePlugin {
    onTypeConfig(typeConfig) {
        var _entityMapping_get, _typeConfig_extensions, _typeConfig_extensions_apollo, _typeConfig_extensions1, _typeConfig_extensions2, _typeConfig_extensions3;
        const entityConfig = (_entityMapping_get = entityMapping.get(this.builder)) === null || _entityMapping_get === void 0 ? void 0 : _entityMapping_get.get(typeConfig.name);
        const apollo = entityConfig ? {
            ...(_typeConfig_extensions = typeConfig.extensions) === null || _typeConfig_extensions === void 0 ? void 0 : _typeConfig_extensions.apollo,
            subgraph: {
                ...(_typeConfig_extensions1 = typeConfig.extensions) === null || _typeConfig_extensions1 === void 0 ? void 0 : (_typeConfig_extensions_apollo = _typeConfig_extensions1.apollo) === null || _typeConfig_extensions_apollo === void 0 ? void 0 : _typeConfig_extensions_apollo.subgraph,
                resolveReference: entityConfig.resolveReference
            }
        } : (_typeConfig_extensions2 = typeConfig.extensions) === null || _typeConfig_extensions2 === void 0 ? void 0 : _typeConfig_extensions2.apollo;
        const typeDirectives = [
            ...entityConfig ? keyDirective(entityConfig.key) : [],
            ...(entityConfig === null || entityConfig === void 0 ? void 0 : entityConfig.interfaceObject) ? [
                {
                    name: "interfaceObject",
                    args: {}
                }
            ] : [],
            ...getCommonDirectives(typeConfig)
        ];
        addUsedDirectives(this.builder, typeDirectives.map((d) => d.name));
        return {
            ...typeConfig,
            extensions: {
                ...typeConfig.extensions,
                apollo,
                directives: mergeDirectives((_typeConfig_extensions3 = typeConfig.extensions) === null || _typeConfig_extensions3 === void 0 ? void 0 : _typeConfig_extensions3.directives, typeDirectives)
            }
        };
    }
    onOutputFieldConfig(fieldConfig) {
        var _fieldConfig_extensions;
        const options = fieldConfig.pothosOptions;
        const ref = Array.isArray(options.type) ? options.type[0] : options.type;
        const resolve = fieldConfig.kind === "ExternalEntity" ? defaultFieldResolver : fieldConfig.resolve;
        const fieldDirectives = [
            options.requires ? {
                name: "requires",
                args: {
                    fields: options.requires.selection
                }
            } : null,
            fieldConfig.kind === "ExternalEntity" ? {
                name: "external"
            } : null,
            providesMap.has(ref) ? {
                name: "provides",
                args: {
                    fields: providesMap.get(ref)
                }
            } : null,
            fieldConfig.pothosOptions.override ? {
                name: "override",
                args: fieldConfig.pothosOptions.override
            } : null,
            ...getCommonDirectives(fieldConfig)
        ].filter(Boolean);
        addUsedDirectives(this.builder, fieldDirectives.map((d) => d.name));
        const directives = mergeDirectives((_fieldConfig_extensions = fieldConfig.extensions) === null || _fieldConfig_extensions === void 0 ? void 0 : _fieldConfig_extensions.directives, fieldDirectives);
        return {
            ...fieldConfig,
            resolve,
            extensions: {
                ...fieldConfig.extensions,
                directives
            }
        };
    }
    onInputFieldConfig(fieldConfig) {
        return addCommonDirectives(this.builder, fieldConfig);
    }
    onEnumValueConfig(valueConfig) {
        return addCommonDirectives(this.builder, valueConfig);
    }
}
function getCommonDirectives(config) {
    var _config_pothosOptions_tag;
    const tags = typeof config.pothosOptions.tag === "string" ? [
        config.pothosOptions.tag
    ] : (_config_pothosOptions_tag = config.pothosOptions.tag) !== null && _config_pothosOptions_tag !== void 0 ? _config_pothosOptions_tag : [];
    const tagDirectives = tags.map((tag) => ({
        name: "tag",
        args: {
            name: tag
        }
    }));
    const requiresScopes = config.pothosOptions.requiresScopes ? {
        name: "requiresScopes",
        args: {
            scopes: config.pothosOptions.requiresScopes
        }
    } : null;
    const policy = config.pothosOptions.policy ? {
        name: "policy",
        args: {
            policies: config.pothosOptions.policy
        }
    } : null;
    const cost = config.pothosOptions.cost !== undefined ? {
        name: "cost",
        args: {
            weight: config.pothosOptions.cost
        }
    } : null;
    const listSize = config.pothosOptions.listSize ? {
        name: "listSize",
        args: Object.fromEntries(Object.entries(config.pothosOptions.listSize).filter(([, v]) => v !== undefined))
    } : null;
    return [
        config.pothosOptions.inaccessible ? {
            name: "inaccessible"
        } : null,
        config.pothosOptions.shareable ? {
            name: "shareable"
        } : null,
        config.pothosOptions.authenticated ? {
            name: "authenticated"
        } : null,
        requiresScopes,
        policy,
        cost,
        listSize,
        ...tagDirectives
    ].filter(Boolean);
}
function addCommonDirectives(builder, config) {
    var _config_extensions;
    const commonDirectives = getCommonDirectives(config);
    addUsedDirectives(builder, commonDirectives.map((d) => d.name));
    const directives = mergeDirectives((_config_extensions = config.extensions) === null || _config_extensions === void 0 ? void 0 : _config_extensions.directives, commonDirectives);
    return {
        ...config,
        extensions: {
            ...config.extensions,
            directives
        }
    };
}
SchemaBuilder.registerPlugin(pluginName, PothosFederationPlugin);
//# sourceMappingURL=index.js.map