1.6.5 (#51)

Author: yoavkarako

CHANGELOG.md

@@ -1,4 +1,6 @@
 # Change Log
+##### 1.6.5
+- Allow override of the is-resolved-field logic in projection and update validation
 ##### 1.6.4
 - `$all`
 ##### 1.6.3

README.md

@@ -1,7 +1,7 @@
 # graphql-to-mongodb 
 [![Build Status](https://travis-ci.org/Soluto/graphql-to-mongodb.svg?branch=master)](https://travis-ci.org/Soluto/graphql-to-mongodb)
 
-If you want to give your Nodejs GraphQL service a whole lot of the power of the MongoDb database you have standing behind it with very little hassle, you've come to the right place!
+If you want to grant your Nodejs GraphQL service a whole lot of the power of the MongoDb database standing behind it with very little hassle, you've come to the right place!
 
 ### [Examples](./examples)
 ### [Change Log](./CHANGELOG.md)
@@ -31,11 +31,11 @@ new GraphQLObjectType({
 ```
 #### An example GraphQL query supported by the package:
 
-Queries the first 50 persons, oldest first,  over the age of 18, and whose first name is John
+Queries the first 50 people, oldest first, over the age of 18, and whose first name is John.
 
 ```
 {
-    person (
+    people (
         filter: {
             age: { GT: 18 },
             name: { 
@@ -51,7 +51,7 @@ Queries the first 50 persons, oldest first,  over the age of 18, and whose first
 }
 ```
 
-**To implement, we'll define the peron query field in our GraphQL scheme like so:**
+**To implement, we'll define the people query field in our GraphQL scheme like so:**
 
 
 ```js
@@ -84,7 +84,7 @@ You'll notice that integrating the package takes little more than adding some fa
 
 **The following field is added to the schema (copied from graphiQl):**
 ```
-person(
+people(
     filter: PersonFilterType
     sort: PersonSortType
     pagination: GraphQLPaginationType

index.ts

@@ -2,13 +2,13 @@ export { getGraphQLFilterType } from './src/graphQLFilterType';
 export { getMongoDbFilter, MongoDbFilter } from './src/mongoDbFilter';
 export { getGraphQLUpdateType } from './src/graphQLUpdateType';
 export { getGraphQLInsertType } from './src/graphQLInsertType';
-export { getMongoDbUpdate } from './src/mongoDbUpdate';
+export { getMongoDbUpdate, UpdateObj } from './src/mongoDbUpdate';
 export { validateUpdateArgs } from "./src/mongoDbUpdateValidation";
 export { default as GraphQLPaginationType } from './src/graphQLPaginationType';
 export { getGraphQLSortType, GraphQLSortType } from './src/graphQLSortType';
-export { default as getMongoDbSort } from './src/mongoDbSort';
-export { getMongoDbProjection, MongoDbProjection } from './src/mongoDbProjection';
-export { getMongoDbQueryResolver, getGraphQLQueryArgs, QueryOptions } from './src/queryResolver';
+export { default as getMongoDbSort, MongoDbSort } from './src/mongoDbSort';
+export { getMongoDbProjection, MongoDbProjection, GetMongoDbProjectionOptions } from './src/mongoDbProjection';
+export { getMongoDbQueryResolver, getGraphQLQueryArgs, QueryOptions, MongoDbOptions } from './src/queryResolver';
 export { getMongoDbUpdateResolver, getGraphQLUpdateArgs, UpdateOptions } from './src/updateResolver';
 export { setLogger, getLogger } from './src/logger';
 export { getTypesCache, clearTypesCache } from './src/common';

package.json

@@ -1,7 +1,7 @@
 {
   "name": "graphql-to-mongodb",
-  "version": "1.6.4",
-  "description": "Generic run-time generation of input filter types for existing graphql types and parsing client requests to mongodb queries",
+  "version": "1.6.5",
+  "description": "Generic run-time generation of input filter types for existing graphql types, and parsing of said input types into MongoDB queries",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "scripts": {
@@ -31,5 +31,12 @@
   },
   "peerDependencies": {
     "graphql": "^14.2.1"
-  }
+  },
+  "keywords": [
+    "graphql",
+    "mongodb",
+    "generate",
+    "backend",
+    "binding"
+  ]
 }

src/mongoDbProjection.ts

@@ -1,36 +1,49 @@
 import { getInnerType, flatten, addPrefixToProperties, GraphQLFieldsType } from './common';
-import { isType, GraphQLResolveInfo, SelectionNode, FragmentSpreadNode } from 'graphql';
+import { isType, GraphQLResolveInfo, SelectionNode, FragmentSpreadNode, GraphQLField } from 'graphql';
 import { logOnError } from './logger';
 
 export interface MongoDbProjection {
     [key: string]: 1
 };
 
-export const getMongoDbProjection = logOnError((info: GraphQLResolveInfo, graphQLFieldsType: GraphQLFieldsType, ...excludedFields: string[]): MongoDbProjection => {
+export interface GetMongoDbProjectionOptions {
+    isResolvedField: (field: GraphQLField<any, any>) => boolean;
+    excludedFields: string[];
+}
+
+const defaultOptions: GetMongoDbProjectionOptions = {
+    isResolvedField: ((field: GraphQLField<any, any>) => !!field.resolve),
+    excludedFields: [],
+}
+
+export const getMongoDbProjection = logOnError((info: GraphQLResolveInfo, graphQLFieldsType: GraphQLFieldsType, options: GetMongoDbProjectionOptions = defaultOptions): MongoDbProjection => {
     if (!Object.keys(info).includes('fieldNodes')) throw 'First argument of "getMongoDbProjection" must be a GraphQLResolveInfo';
     if (!isType(graphQLFieldsType)) throw 'Second argument of "getMongoDbProjection" must be a GraphQLType';
 
     const nodes = flatten(info.fieldNodes.map(_ => [..._.selectionSet.selections]));
 
-    const projection = getSelectedProjection(nodes, graphQLFieldsType, { info, fragments: {} });
+    const projection = getSelectedProjection(nodes, graphQLFieldsType, { info, fragments: {} }, {
+        ...options,
+        isResolvedField: options.isResolvedField || ((field: GraphQLField<any, any>) => !!field.resolve)
+    });
 
     return omitRedundantProjection(projection);
 });
 
 function getSelectedProjection(
-    selectionNodes: SelectionNode[], 
-    graphQLFieldsType: GraphQLFieldsType, 
-    extra: { info: GraphQLResolveInfo, fragments: { [key: string]: MongoDbProjection } }, 
-    ...excludedFields: string[]): MongoDbProjection {
+    selectionNodes: SelectionNode[],
+    graphQLFieldsType: GraphQLFieldsType,
+    extra: { info: GraphQLResolveInfo, fragments: { [key: string]: MongoDbProjection } },
+    options: GetMongoDbProjectionOptions = defaultOptions): MongoDbProjection {
     const fields = graphQLFieldsType.getFields()
 
     return selectionNodes.reduce((projection, node) => {
         if (node.kind === 'Field') {
-            if (node.name.value === '__typename' || excludedFields.includes(node.name.value)) return projection;
+            if (node.name.value === '__typename' || options.excludedFields.includes(node.name.value)) return projection;
 
             const field = fields[node.name.value];
 
-            if (!!field.resolve)  {
+            if (options.isResolvedField(field)) {
                 const dependencies: string[] = field["dependencies"] || [];
                 const dependenciesProjection = dependencies.reduce((agg, dependency) => ({ ...agg, [dependency]: 1 }), {});
                 return {
@@ -44,7 +57,7 @@ function getSelectedProjection(
                 [node.name.value]: 1
             };
 
-            const nested = getSelectedProjection([...node.selectionSet.selections], getInnerType(field.type) as GraphQLFieldsType, extra);
+            const nested = getSelectedProjection([...node.selectionSet.selections], getInnerType(field.type) as GraphQLFieldsType, extra, options);
 
             return {
                 ...projection,
@@ -54,31 +67,32 @@ function getSelectedProjection(
             const type = extra.info.schema.getType(node.typeCondition.name.value);
             return {
                 ...projection,
-                ...getSelectedProjection([...node.selectionSet.selections], type as GraphQLFieldsType, extra, ...excludedFields)
+                ...getSelectedProjection([...node.selectionSet.selections], type as GraphQLFieldsType, extra, options)
             };
         } else if (node.kind === 'FragmentSpread') {
             return {
                 ...projection,
-                ...getFragmentProjection(node, graphQLFieldsType, extra)
+                ...getFragmentProjection(node, graphQLFieldsType, extra, options)
             };
         }
     }, {});
 }
 
 function getFragmentProjection(
-    fragmentSpreadNode: FragmentSpreadNode, 
-    graphQLFieldsType: GraphQLFieldsType, 
-    extra: { info: GraphQLResolveInfo, fragments: { [key: string]: MongoDbProjection } }): MongoDbProjection {
+    fragmentSpreadNode: FragmentSpreadNode,
+    graphQLFieldsType: GraphQLFieldsType,
+    extra: { info: GraphQLResolveInfo, fragments: { [key: string]: MongoDbProjection } },
+    options: GetMongoDbProjectionOptions = defaultOptions): MongoDbProjection {
     const fragmentName = fragmentSpreadNode.name.value;
     if (extra.fragments[fragmentName]) return extra.fragments[fragmentName];
     const fragmentNode = extra.info.fragments[fragmentName];
-    extra.fragments[fragmentName] = getSelectedProjection([...fragmentNode.selectionSet.selections], graphQLFieldsType, extra);
+    extra.fragments[fragmentName] = getSelectedProjection([...fragmentNode.selectionSet.selections], graphQLFieldsType, extra, options);
     return extra.fragments[fragmentName];
 }
 
 function omitRedundantProjection(projection: MongoDbProjection) {
     return Object.keys(projection).reduce((proj, key) => {
-        if (Object.keys(projection).some(otherKey => 
+        if (Object.keys(projection).some(otherKey =>
             otherKey !== key && new RegExp(`^${otherKey}[.]`).test(key))) {
             return proj;
         }

src/mongoDbUpdateValidation.ts

@@ -1,5 +1,5 @@
 import { UpdateArgs } from "./mongoDbUpdate";
-import { GraphQLObjectType, GraphQLType, GraphQLNonNull, GraphQLList, GraphQLFieldMap, GraphQLError } from "graphql";
+import { GraphQLObjectType, GraphQLType, GraphQLNonNull, GraphQLList, GraphQLFieldMap, GraphQLField, GraphQLError } from "graphql";
 import { isNonNullField, getInnerType, flatten, isListField } from "./common";
 import { OVERWRITE } from "./graphQLUpdateType";
 
@@ -13,35 +13,52 @@ export enum ShouldAssert {
     False
 }
 
-export function validateUpdateArgs(updateArgs: UpdateArgs, graphQLType: GraphQLObjectType, overwrite: boolean): void {
+export interface ValidateUpdateArgsOptions {
+    overwrite: boolean;
+    isResolvedField?: (field: GraphQLField<any, any>) => boolean;
+}
+
+const defaultOptions: ValidateUpdateArgsOptions = {
+    overwrite: false,
+};
+
+export function validateUpdateArgs(updateArgs: UpdateArgs, graphQLType: GraphQLObjectType, options: ValidateUpdateArgsOptions = defaultOptions): void {
     let errors: string[] = [];
 
-    errors = errors.concat(validateNonNullableFieldsOuter(updateArgs, overwrite, graphQLType));
+    errors = errors.concat(validateNonNullableFieldsOuter(updateArgs, graphQLType, options));
 
     if (errors.length > 0) {
         throw new GraphQLError(errors.join("\n"));
     }
 }
 
-function validateNonNullableFieldsOuter(updateArgs: UpdateArgs, overwrite: boolean, graphQLType: GraphQLObjectType): string[] {
+function validateNonNullableFieldsOuter(
+    updateArgs: UpdateArgs,
+    graphQLType: GraphQLObjectType,
+    { overwrite, isResolvedField }: ValidateUpdateArgsOptions): string[] {
     const shouldAssert: ShouldAssert = !!updateArgs.setOnInsert
         ? ShouldAssert.True
         : overwrite
             ? ShouldAssert.DefaultTrueRoot
             : ShouldAssert.False;
 
-    return validateNonNullableFields(Object.keys(updateArgs).map(_ => updateArgs[_]), graphQLType, shouldAssert);
+    return validateNonNullableFields(Object.keys(updateArgs).map(_ => updateArgs[_]), graphQLType, shouldAssert, isResolvedField);
 }
 
-export function validateNonNullableFields(objects: object[], graphQLType: GraphQLObjectType, shouldAssert: ShouldAssert, path: string[] = []): string[] {
+export function validateNonNullableFields(
+    objects: object[],
+    graphQLType: GraphQLObjectType,
+    shouldAssert: ShouldAssert,
+    isResolvedField: ((field: GraphQLField<any, any>) => boolean) = (field: GraphQLField<any, any>) => !!field.resolve,
+    path: string[] = []): string[] {
     const typeFields = graphQLType.getFields();
 
     const errors: string[] = shouldAssert === ShouldAssert.True ? validateNonNullableFieldsAssert(objects, typeFields, path) : [];
 
     const overwrite = objects.map(_ => _[OVERWRITE]).filter(_ => _)[0];
     shouldAssert = getShouldAssert(shouldAssert, overwrite);
 
-    return [...errors, ...validateNonNullableFieldsTraverse(objects, typeFields, shouldAssert, path)];
+    return [...errors, ...validateNonNullableFieldsTraverse(objects, typeFields, shouldAssert, isResolvedField, path)];
 }
 
 export function validateNonNullableFieldsAssert(objects: object[], typeFields: GraphQLFieldMap<any, any>, path: string[] = []): string[] {
@@ -98,25 +115,30 @@ export function getShouldAssert(current: ShouldAssert, input?: boolean): ShouldA
     return current;
 }
 
-export function validateNonNullableFieldsTraverse(objects: object[], typeFields: GraphQLFieldMap<any, any>, shouldAssert: ShouldAssert, path: string[] = []): string[] {
+export function validateNonNullableFieldsTraverse(
+    objects: object[],
+    typeFields: GraphQLFieldMap<any, any>,
+    shouldAssert: ShouldAssert,
+    isResolvedField: (field: GraphQLField<any, any>) => boolean = (field: GraphQLField<any, any>) => !!field.resolve,
+    path: string[] = []): string[] {
     let keys: string[] = Array.from(new Set(flatten(objects.map(_ => Object.keys(_)))));
 
     return keys.reduce((agg, key) => {
         const field = typeFields[key];
         const type = field.type;
         const innerType = getInnerType(type);
 
-        if (!(innerType instanceof GraphQLObjectType) || field.resolve) {
+        if (!(innerType instanceof GraphQLObjectType) || isResolvedField(field)) {
             return agg;
         }
 
         const newPath = [...path, key];
         const values = objects.map(_ => _[key]).filter(_ => _);
 
         if (isListField(type)) {
-            return [...agg, ...flatten(flattenListField(values, type).map(_ => validateNonNullableFields([_], innerType, ShouldAssert.True, newPath)))];
+            return [...agg, ...flatten(flattenListField(values, type).map(_ => validateNonNullableFields([_], innerType, ShouldAssert.True, isResolvedField, newPath)))];
         } else {
-            return [...agg, ...validateNonNullableFields(values, innerType, shouldAssert, newPath)];
+            return [...agg, ...validateNonNullableFields(values, innerType, shouldAssert, isResolvedField, newPath)];
         }
     }, []);
 }

src/queryResolver.ts

@@ -1,10 +1,10 @@
 import { getMongoDbFilter, MongoDbFilter } from './mongoDbFilter';
-import { getMongoDbProjection, MongoDbProjection } from './mongoDbProjection';
+import { getMongoDbProjection, MongoDbProjection, GetMongoDbProjectionOptions } from './mongoDbProjection';
 import { getGraphQLFilterType } from './graphQLFilterType';
 import { getGraphQLSortType } from './graphQLSortType';
 import GraphQLPaginationType from './graphQLPaginationType';
 import getMongoDbSort, { MongoDbSort } from "./mongoDbSort";
-import { isType, GraphQLResolveInfo, GraphQLFieldResolver, GraphQLObjectType, GraphQLInputObjectType } from 'graphql';
+import { isType, GraphQLResolveInfo, GraphQLFieldResolver, GraphQLInputObjectType, GraphQLField } from 'graphql';
 import { GraphQLFieldsType } from './common';
 
 export interface QueryCallback<TSource, TContext> {
@@ -26,12 +26,14 @@ export interface MongoDbOptions {
     projection?: MongoDbProjection;
 }
 
-export interface QueryOptions {
+export type QueryOptions = {
     differentOutputType?: boolean;
-};
+} & Partial<GetMongoDbProjectionOptions>;
 
 const defaultOptions: Required<QueryOptions> = {
-    differentOutputType: false
+    differentOutputType: false,
+    excludedFields: [],
+    isResolvedField: (field: GraphQLField<any, any>) => !!field.resolve
 };
 
 export function getMongoDbQueryResolver<TSource, TContext>(
@@ -40,24 +42,24 @@ export function getMongoDbQueryResolver<TSource, TContext>(
     queryOptions?: QueryOptions): GraphQLFieldResolver<TSource, TContext> {
     if (!isType(graphQLType)) throw 'getMongoDbQueryResolver must recieve a graphql type';
     if (typeof queryCallback !== 'function') throw 'getMongoDbQueryResolver must recieve a queryCallback function';
-    const requiredQueryOptions: Required<QueryOptions> = { ...defaultOptions, ...queryOptions };
+    const requiredQueryOptions = { ...defaultOptions, ...queryOptions };
 
     return async (source: TSource, args: { [argName: string]: any }, context: TContext, info: GraphQLResolveInfo): Promise<any> => {
         const filter = getMongoDbFilter(graphQLType, args.filter);
-        const projection = requiredQueryOptions.differentOutputType ? undefined : getMongoDbProjection(info, graphQLType);
+        const projection = requiredQueryOptions.differentOutputType ? undefined : getMongoDbProjection(info, graphQLType, requiredQueryOptions);
         const options: MongoDbOptions = { projection };
         if (args.sort) options.sort = getMongoDbSort(args.sort);
         if (args.pagination && args.pagination.limit) options.limit = args.pagination.limit;
         if (args.pagination && args.pagination.skip) options.skip = args.pagination.skip;
-        
+
         return await queryCallback(filter, projection, options, source, args, context, info);
     }
 }
 
-export function getGraphQLQueryArgs(graphQLType: GraphQLFieldsType): { [key: string]: { type: GraphQLInputObjectType } } & { 
+export function getGraphQLQueryArgs(graphQLType: GraphQLFieldsType): { [key: string]: { type: GraphQLInputObjectType } } & {
     filter: { type: GraphQLInputObjectType },
-    sort: { type: GraphQLInputObjectType } ,
-    pagination: { type: GraphQLInputObjectType } 
+    sort: { type: GraphQLInputObjectType },
+    pagination: { type: GraphQLInputObjectType }
 } {
     return {
         filter: { type: getGraphQLFilterType(graphQLType) },