@graphql-codegen/plugin-helpers 2.5.0-alpha-252a8d50d.0 → 2.5.0-alpha-2fbcdb6d3.0

package/esm/federation.js

@@ -0,0 +1,251 @@
+import { parse, GraphQLObjectType, isObjectType, } from 'graphql';
+import merge from 'lodash/merge.js';
+import { getBaseType } from './utils.js';
+import { MapperKind, mapSchema, astFromObjectType, getRootTypeNames } from '@graphql-tools/utils';
+import { oldVisit } from './index.js';
+/**
+ * Federation Spec
+ */
+export const federationSpec = parse(/* GraphQL */ `
+  scalar _FieldSet
+
+  directive @external on FIELD_DEFINITION
+  directive @requires(fields: _FieldSet!) on FIELD_DEFINITION
+  directive @provides(fields: _FieldSet!) on FIELD_DEFINITION
+  directive @key(fields: _FieldSet!) on OBJECT | INTERFACE
+`);
+/**
+ * Adds `__resolveReference` in each ObjectType involved in Federation.
+ * @param schema
+ */
+export function addFederationReferencesToSchema(schema) {
+    return mapSchema(schema, {
+        [MapperKind.OBJECT_TYPE]: type => {
+            if (isFederationObjectType(type, schema)) {
+                const typeConfig = type.toConfig();
+                typeConfig.fields = {
+                    [resolveReferenceFieldName]: {
+                        type,
+                    },
+                    ...typeConfig.fields,
+                };
+                return new GraphQLObjectType(typeConfig);
+            }
+            return type;
+        },
+    });
+}
+/**
+ * Removes Federation Spec from GraphQL Schema
+ * @param schema
+ * @param config
+ */
+export function removeFederation(schema) {
+    return mapSchema(schema, {
+        [MapperKind.QUERY]: queryType => {
+            const queryTypeConfig = queryType.toConfig();
+            delete queryTypeConfig.fields._entities;
+            delete queryTypeConfig.fields._service;
+            return new GraphQLObjectType(queryTypeConfig);
+        },
+        [MapperKind.UNION_TYPE]: unionType => {
+            const unionTypeName = unionType.name;
+            if (unionTypeName === '_Entity' || unionTypeName === '_Any') {
+                return null;
+            }
+            return unionType;
+        },
+        [MapperKind.OBJECT_TYPE]: objectType => {
+            if (objectType.name === '_Service') {
+                return null;
+            }
+            return objectType;
+        },
+    });
+}
+const resolveReferenceFieldName = '__resolveReference';
+export class ApolloFederation {
+    constructor({ enabled, schema }) {
+        this.enabled = false;
+        this.enabled = enabled;
+        this.schema = schema;
+        this.providesMap = this.createMapOfProvides();
+    }
+    /**
+     * Excludes types definde by Federation
+     * @param typeNames List of type names
+     */
+    filterTypeNames(typeNames) {
+        return this.enabled ? typeNames.filter(t => t !== '_FieldSet') : typeNames;
+    }
+    /**
+     * Excludes `__resolveReference` fields
+     * @param fieldNames List of field names
+     */
+    filterFieldNames(fieldNames) {
+        return this.enabled ? fieldNames.filter(t => t !== resolveReferenceFieldName) : fieldNames;
+    }
+    /**
+     * Decides if directive should not be generated
+     * @param name directive's name
+     */
+    skipDirective(name) {
+        return this.enabled && ['external', 'requires', 'provides', 'key'].includes(name);
+    }
+    /**
+     * Decides if scalar should not be generated
+     * @param name directive's name
+     */
+    skipScalar(name) {
+        return this.enabled && name === '_FieldSet';
+    }
+    /**
+     * Decides if field should not be generated
+     * @param data
+     */
+    skipField({ fieldNode, parentType }) {
+        if (!this.enabled || !isObjectType(parentType) || !isFederationObjectType(parentType, this.schema)) {
+            return false;
+        }
+        return this.isExternalAndNotProvided(fieldNode, parentType);
+    }
+    isResolveReferenceField(fieldNode) {
+        const name = typeof fieldNode.name === 'string' ? fieldNode.name : fieldNode.name.value;
+        return this.enabled && name === resolveReferenceFieldName;
+    }
+    /**
+     * Transforms ParentType signature in ObjectTypes involved in Federation
+     * @param data
+     */
+    transformParentType({ fieldNode, parentType, parentTypeSignature, }) {
+        if (this.enabled &&
+            isObjectType(parentType) &&
+            isFederationObjectType(parentType, this.schema) &&
+            (isTypeExtension(parentType, this.schema) || fieldNode.name.value === resolveReferenceFieldName)) {
+            const keys = getDirectivesByName('key', parentType);
+            if (keys.length) {
+                const outputs = [`{ __typename: '${parentType.name}' } &`];
+                // Look for @requires and see what the service needs and gets
+                const requires = getDirectivesByName('requires', fieldNode).map(this.extractKeyOrRequiresFieldSet);
+                const requiredFields = this.translateFieldSet(merge({}, ...requires), parentTypeSignature);
+                // @key() @key() - "primary keys" in Federation
+                const primaryKeys = keys.map(def => {
+                    const fields = this.extractKeyOrRequiresFieldSet(def);
+                    return this.translateFieldSet(fields, parentTypeSignature);
+                });
+                const [open, close] = primaryKeys.length > 1 ? ['(', ')'] : ['', ''];
+                outputs.push([open, primaryKeys.join(' | '), close].join(''));
+                // include required fields
+                if (requires.length) {
+                    outputs.push(`& ${requiredFields}`);
+                }
+                return outputs.join(' ');
+            }
+        }
+        return parentTypeSignature;
+    }
+    isExternalAndNotProvided(fieldNode, objectType) {
+        return this.isExternal(fieldNode) && !this.hasProvides(objectType, fieldNode);
+    }
+    isExternal(node) {
+        return getDirectivesByName('external', node).length > 0;
+    }
+    hasProvides(objectType, node) {
+        const fields = this.providesMap[isObjectType(objectType) ? objectType.name : objectType.name.value];
+        if (fields && fields.length) {
+            return fields.includes(node.name.value);
+        }
+        return false;
+    }
+    translateFieldSet(fields, parentTypeRef) {
+        return `GraphQLRecursivePick<${parentTypeRef}, ${JSON.stringify(fields)}>`;
+    }
+    extractKeyOrRequiresFieldSet(directive) {
+        const arg = directive.arguments.find(arg => arg.name.value === 'fields');
+        const { value } = arg.value;
+        return oldVisit(parse(`{${value}}`), {
+            leave: {
+                SelectionSet(node) {
+                    return node.selections.reduce((accum, field) => {
+                        accum[field.name] = field.selection;
+                        return accum;
+                    }, {});
+                },
+                Field(node) {
+                    return {
+                        name: node.name.value,
+                        selection: node.selectionSet ? node.selectionSet : true,
+                    };
+                },
+                Document(node) {
+                    return node.definitions.find((def) => def.kind === 'OperationDefinition' && def.operation === 'query').selectionSet;
+                },
+            },
+        });
+    }
+    extractProvidesFieldSet(directive) {
+        const arg = directive.arguments.find(arg => arg.name.value === 'fields');
+        const { value } = arg.value;
+        if (/[{}]/gi.test(value)) {
+            throw new Error('Nested fields in _FieldSet is not supported in the @provides directive');
+        }
+        return value.split(/\s+/g);
+    }
+    createMapOfProvides() {
+        const providesMap = {};
+        Object.keys(this.schema.getTypeMap()).forEach(typename => {
+            const objectType = this.schema.getType(typename);
+            if (isObjectType(objectType)) {
+                Object.values(objectType.getFields()).forEach(field => {
+                    const provides = getDirectivesByName('provides', field.astNode)
+                        .map(this.extractProvidesFieldSet)
+                        .reduce((prev, curr) => [...prev, ...curr], []);
+                    const ofType = getBaseType(field.type);
+                    if (!providesMap[ofType.name]) {
+                        providesMap[ofType.name] = [];
+                    }
+                    providesMap[ofType.name].push(...provides);
+                });
+            }
+        });
+        return providesMap;
+    }
+}
+/**
+ * Checks if Object Type is involved in Federation. Based on `@key` directive
+ * @param node Type
+ */
+function isFederationObjectType(node, schema) {
+    const { name: { value: name }, directives, } = isObjectType(node) ? astFromObjectType(node, schema) : node;
+    const rootTypeNames = getRootTypeNames(schema);
+    const isNotRoot = !rootTypeNames.has(name);
+    const isNotIntrospection = !name.startsWith('__');
+    const hasKeyDirective = directives.some(d => d.name.value === 'key');
+    return isNotRoot && isNotIntrospection && hasKeyDirective;
+}
+/**
+ * Extracts directives from a node based on directive's name
+ * @param name directive name
+ * @param node ObjectType or Field
+ */
+function getDirectivesByName(name, node) {
+    var _a;
+    let astNode;
+    if (isObjectType(node)) {
+        astNode = node.astNode;
+    }
+    else {
+        astNode = node;
+    }
+    return ((_a = astNode === null || astNode === void 0 ? void 0 : astNode.directives) === null || _a === void 0 ? void 0 : _a.filter(d => d.name.value === name)) || [];
+}
+/**
+ * Checks if the Object Type extends a federated type from a remote schema.
+ * Based on if any of its fields contain the `@external` directive
+ * @param node Type
+ */
+function isTypeExtension(node, schema) {
+    var _a;
+    const definition = isObjectType(node) ? node.astNode || astFromObjectType(node, schema) : node;
+    return (_a = definition.fields) === null || _a === void 0 ? void 0 : _a.some(field => getDirectivesByName('external', field).length);
+}

package/esm/getCachedDocumentNodeFromSchema.js

@@ -0,0 +1,2 @@
+import { getDocumentNodeFromSchema, memoize1 } from '@graphql-tools/utils';
+export const getCachedDocumentNodeFromSchema = memoize1(getDocumentNodeFromSchema);

package/esm/helpers.js

@@ -0,0 +1,159 @@
+import { visit, isListType, isObjectType, Kind, isNonNullType, } from 'graphql';
+import { getBaseType } from './utils.js';
+export function isOutputConfigArray(type) {
+    return Array.isArray(type);
+}
+export function isConfiguredOutput(type) {
+    return (typeof type === 'object' && type.plugins) || type.preset;
+}
+export function normalizeOutputParam(config) {
+    // In case of direct array with a list of plugins
+    if (isOutputConfigArray(config)) {
+        return {
+            documents: [],
+            schema: [],
+            plugins: isConfiguredOutput(config) ? config.plugins : config,
+        };
+    }
+    if (isConfiguredOutput(config)) {
+        return config;
+    }
+    throw new Error(`Invalid "generates" config!`);
+}
+export function normalizeInstanceOrArray(type) {
+    if (Array.isArray(type)) {
+        return type;
+    }
+    if (!type) {
+        return [];
+    }
+    return [type];
+}
+export function normalizeConfig(config) {
+    if (typeof config === 'string') {
+        return [{ [config]: {} }];
+    }
+    if (Array.isArray(config)) {
+        return config.map(plugin => (typeof plugin === 'string' ? { [plugin]: {} } : plugin));
+    }
+    if (typeof config === 'object') {
+        return Object.keys(config).reduce((prev, pluginName) => [...prev, { [pluginName]: config[pluginName] }], []);
+    }
+    return [];
+}
+export function hasNullableTypeRecursively(type) {
+    if (!isNonNullType(type)) {
+        return true;
+    }
+    if (isListType(type) || isNonNullType(type)) {
+        return hasNullableTypeRecursively(type.ofType);
+    }
+    return false;
+}
+export function isUsingTypes(document, externalFragments, schema) {
+    let foundFields = 0;
+    const typesStack = [];
+    visit(document, {
+        SelectionSet: {
+            enter(node, key, parent, anscestors) {
+                const insideIgnoredFragment = anscestors.find((f) => f.kind && f.kind === 'FragmentDefinition' && externalFragments.includes(f.name.value));
+                if (insideIgnoredFragment) {
+                    return;
+                }
+                const selections = node.selections || [];
+                if (schema && selections.length > 0) {
+                    const nextTypeName = (() => {
+                        if (parent.kind === Kind.FRAGMENT_DEFINITION) {
+                            return parent.typeCondition.name.value;
+                        }
+                        if (parent.kind === Kind.FIELD) {
+                            const lastType = typesStack[typesStack.length - 1];
+                            if (!lastType) {
+                                throw new Error(`Unable to find parent type! Please make sure you operation passes validation`);
+                            }
+                            const field = lastType.getFields()[parent.name.value];
+                            if (!field) {
+                                throw new Error(`Unable to find field "${parent.name.value}" on type "${lastType}"!`);
+                            }
+                            return getBaseType(field.type).name;
+                        }
+                        if (parent.kind === Kind.OPERATION_DEFINITION) {
+                            if (parent.operation === 'query') {
+                                return schema.getQueryType().name;
+                            }
+                            if (parent.operation === 'mutation') {
+                                return schema.getMutationType().name;
+                            }
+                            if (parent.operation === 'subscription') {
+                                return schema.getSubscriptionType().name;
+                            }
+                        }
+                        else if (parent.kind === Kind.INLINE_FRAGMENT) {
+                            if (parent.typeCondition) {
+                                return parent.typeCondition.name.value;
+                            }
+                            return typesStack[typesStack.length - 1].name;
+                        }
+                        return null;
+                    })();
+                    typesStack.push(schema.getType(nextTypeName));
+                }
+            },
+            leave(node) {
+                const selections = node.selections || [];
+                if (schema && selections.length > 0) {
+                    typesStack.pop();
+                }
+            },
+        },
+        Field: {
+            enter: (node, key, parent, path, anscestors) => {
+                if (node.name.value.startsWith('__')) {
+                    return;
+                }
+                const insideIgnoredFragment = anscestors.find((f) => f.kind && f.kind === 'FragmentDefinition' && externalFragments.includes(f.name.value));
+                if (insideIgnoredFragment) {
+                    return;
+                }
+                const selections = node.selectionSet ? node.selectionSet.selections || [] : [];
+                const relevantFragmentSpreads = selections.filter(s => s.kind === Kind.FRAGMENT_SPREAD && !externalFragments.includes(s.name.value));
+                if (selections.length === 0 || relevantFragmentSpreads.length > 0) {
+                    foundFields++;
+                }
+                if (schema) {
+                    const lastType = typesStack[typesStack.length - 1];
+                    if (lastType && isObjectType(lastType)) {
+                        const field = lastType.getFields()[node.name.value];
+                        if (!field) {
+                            throw new Error(`Unable to find field "${node.name.value}" on type "${lastType}"!`);
+                        }
+                        const currentType = field.type;
+                        // To handle `Maybe` usage
+                        if (hasNullableTypeRecursively(currentType)) {
+                            foundFields++;
+                        }
+                    }
+                }
+            },
+        },
+        VariableDefinition: {
+            enter: (node, key, parent, path, anscestors) => {
+                const insideIgnoredFragment = anscestors.find((f) => f.kind && f.kind === 'FragmentDefinition' && externalFragments.includes(f.name.value));
+                if (insideIgnoredFragment) {
+                    return;
+                }
+                foundFields++;
+            },
+        },
+        InputValueDefinition: {
+            enter: (node, key, parent, path, anscestors) => {
+                const insideIgnoredFragment = anscestors.find((f) => f.kind && f.kind === 'FragmentDefinition' && externalFragments.includes(f.name.value));
+                if (insideIgnoredFragment) {
+                    return;
+                }
+                foundFields++;
+            },
+        },
+    });
+    return foundFields > 0;
+}

package/esm/index.js

@@ -0,0 +1,9 @@
+export { resolveExternalModuleAndFn } from './resolve-external-module-and-fn.js';
+export * from './types.js';
+export * from './utils.js';
+export * from './helpers.js';
+export * from './federation.js';
+export * from './errors.js';
+export * from './getCachedDocumentNodeFromSchema.js';
+export * from './oldVisit.js';
+export * from './profiler.js';

package/esm/oldVisit.js

@@ -0,0 +1,16 @@
+import { visit } from 'graphql';
+export function oldVisit(root, { enter: enterVisitors, leave: leaveVisitors, ...newVisitor }) {
+    if (typeof enterVisitors === 'object') {
+        for (const key in enterVisitors) {
+            newVisitor[key] = newVisitor[key] || {};
+            newVisitor[key].enter = enterVisitors[key];
+        }
+    }
+    if (typeof leaveVisitors === 'object') {
+        for (const key in leaveVisitors) {
+            newVisitor[key] = newVisitor[key] || {};
+            newVisitor[key].leave = leaveVisitors[key];
+        }
+    }
+    return visit(root, newVisitor);
+}

package/esm/profiler.js

@@ -0,0 +1,45 @@
+export function createNoopProfiler() {
+    return {
+        run(fn) {
+            return Promise.resolve().then(() => fn());
+        },
+        collect() {
+            return [];
+        },
+    };
+}
+export function createProfiler() {
+    const events = [];
+    return {
+        collect() {
+            return events;
+        },
+        run(fn, name, cat) {
+            let startTime;
+            return Promise.resolve()
+                .then(() => {
+                startTime = process.hrtime();
+            })
+                .then(() => fn())
+                .then(value => {
+                const duration = process.hrtime(startTime);
+                // Trace Event Format documentation:
+                // https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU/preview
+                const event = {
+                    name,
+                    cat,
+                    ph: 'X',
+                    ts: hrtimeToMicroseconds(startTime),
+                    pid: 1,
+                    tid: 0,
+                    dur: hrtimeToMicroseconds(duration),
+                };
+                events.push(event);
+                return value;
+            });
+        },
+    };
+}
+function hrtimeToMicroseconds(hrtime) {
+    return (hrtime[0] * 1e9 + hrtime[1]) / 1000;
+}

package/esm/resolve-external-module-and-fn.js

@@ -0,0 +1,28 @@
+import { createRequire } from 'module';
+import { cwd } from 'process';
+import * as changeCaseAll from 'change-case-all';
+export function resolveExternalModuleAndFn(pointer) {
+    if (typeof pointer === 'function') {
+        return pointer;
+    }
+    // eslint-disable-next-line prefer-const
+    let [moduleName, functionName] = pointer.split('#');
+    // Temp workaround until v2
+    if (moduleName === 'change-case') {
+        moduleName = 'change-case-all';
+    }
+    let loadedModule;
+    if (moduleName === 'change-case-all') {
+        loadedModule = changeCaseAll;
+    }
+    else {
+        // we have to use a path to a filename here (it does not need to exist.)
+        // https://github.com/dotansimha/graphql-code-generator/issues/6553
+        const cwdRequire = createRequire(cwd() + '/index.js');
+        loadedModule = cwdRequire(moduleName);
+        if (!(functionName in loadedModule) && typeof loadedModule !== 'function') {
+            throw new Error(`${functionName} couldn't be found in module ${moduleName}!`);
+        }
+    }
+    return loadedModule[functionName] || loadedModule;
+}

package/esm/types.js

@@ -0,0 +1,3 @@
+export function isComplexPluginOutput(obj) {
+    return typeof obj === 'object' && obj.hasOwnProperty('content');
+}

package/esm/utils.js

@@ -0,0 +1,29 @@
+import { isListType, isNonNullType } from 'graphql';
+export function mergeOutputs(content) {
+    const result = { content: '', prepend: [], append: [] };
+    if (Array.isArray(content)) {
+        content.forEach(item => {
+            if (typeof item === 'string') {
+                result.content += item;
+            }
+            else {
+                result.content += item.content;
+                result.prepend.push(...(item.prepend || []));
+                result.append.push(...(item.append || []));
+            }
+        });
+    }
+    return [...result.prepend, result.content, ...result.append].join('\n');
+}
+export function isWrapperType(t) {
+    return isListType(t) || isNonNullType(t);
+}
+export function getBaseType(type) {
+    if (isWrapperType(type)) {
+        return getBaseType(type.ofType);
+    }
+    return type;
+}
+export function removeNonNullWrapper(type) {
+    return isNonNullType(type) ? type.ofType : type;
+}

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@graphql-codegen/plugin-helpers",
-  "version": "2.5.0-alpha-252a8d50d.0",
+  "version": "2.5.0-alpha-2fbcdb6d3.0",
   "description": "GraphQL Code Generator common utils and types",
   "peerDependencies": {
     "graphql": "^0.8.0 || ^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0"
   },
   "dependencies": {
-    "@graphql-tools/utils": "^8.5.2",
+    "@graphql-tools/utils": "^8.8.0",
     "change-case-all": "1.0.14",
     "common-tags": "1.8.2",
     "import-from": "4.0.0",
     "lodash": "~4.17.0",
-    "tslib": "~2.3.0"
+    "tslib": "~2.4.0"
   },
   "repository": {
     "type": "git",
@@ -19,21 +19,28 @@
     "directory": "packages/utils/plugins-helpers"
   },
   "license": "MIT",
-  "main": "index.js",
-  "module": "index.mjs",
-  "typings": "index.d.ts",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
   "typescript": {
-    "definition": "index.d.ts"
+    "definition": "typings/index.d.ts"
   },
+  "type": "module",
   "exports": {
-    "./package.json": "./package.json",
     ".": {
-      "require": "./index.js",
-      "import": "./index.mjs"
+      "require": {
+        "types": "./typings/index.d.ts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
     },
-    "./*": {
-      "require": "./*.js",
-      "import": "./*.mjs"
-    }
+    "./package.json": "./package.json"
   }
-}
+}

package/{helpers.d.ts → typings/helpers.d.ts}

@@ -1,4 +1,4 @@
-import { Types } from './types';
+import { Types } from './types.js';
 import { DocumentNode, GraphQLSchema, GraphQLOutputType } from 'graphql';
 export declare function isOutputConfigArray(type: any): type is Types.OutputConfig[];
 export declare function isConfiguredOutput(type: any): type is Types.ConfiguredOutput;

package/typings/index.d.ts

@@ -0,0 +1,9 @@
+export { resolveExternalModuleAndFn } from './resolve-external-module-and-fn.js';
+export * from './types.js';
+export * from './utils.js';
+export * from './helpers.js';
+export * from './federation.js';
+export * from './errors.js';
+export * from './getCachedDocumentNodeFromSchema.js';
+export * from './oldVisit.js';
+export * from './profiler.js';