graphql-advanced-projection - npm Package Compare versions

Comparing version 0.3.0 to 0.4.0

package.json

 {
   "name": "graphql-advanced-projection",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Fully customizable MongoDB projection generator.",
@@ -8,3 +8,4 @@ "main": "index.js",
   "scripts": {
-    "test": "jest --coverage",
+    "lint": "eslint --ignore-path .gitignore .",
+    "test": "yarn lint && yarn jest --coverage",
     "coveralls": "cat ./coverage/lcov.info | coveralls"
@@ -20,2 +21,5 @@ },
     "coveralls": "^3.0.0",
+    "eslint": "^4.18.2",
+    "eslint-config-airbnb-base": "^12.1.0",
+    "eslint-plugin-import": "^2.9.0",
     "graphql": ">0.12.3",
@@ -22,0 +26,0 @@ "graphql-tools": "^2.18.0",

src/projection.js

 const _ = require('lodash');
+const validate = require('./validate');
 const logger = require('../logger');
@@ -34,59 +35,36 @@
           logger.debug('Projecting field', sel.name.value);
-          const def = cfg && _.get(cfg.proj, sel.name.value);
-          const goDefault = () => {
-            if (!sel.selectionSet) {
-              logger.trace('>Default', prefix + sel.name.value);
-              proj[prefix + sel.name.value] = 1;
-            } else {
-              const typeRef = info.schema.getType(type);
-              /* istanbul ignore if */
-              if (!typeRef) {
-                /* istanbul ignore next */
-                throw new Error('Type not found', type);
-              }
-              logger.trace('typeRef', typeRef.toString());
-              const field = typeRef.getFields()[sel.name.value];
-              /* istanbul ignore if */
-              if (!field) {
-                /* istanbul ignore next */
-                throw new Error('Field not found', sel.name.value);
-              }
-              const nextTypeRef = field.type;
-              logger.trace('nextTypeRef', nextTypeRef.toString());
-              const core = stripType(nextTypeRef);
-              logger.trace('Recursive', core);
-              Object.assign(proj, gen(root, sel, core));
-            }
-          };
-          const goSimple = (v) => {
-            if (Array.isArray(v)) {
-              v.forEach(goSimple);
-            } else {
-              logger.trace('>Simple', prefix + v);
+          const def = validate(cfg && _.get(cfg.proj, sel.name.value));
+          if (def.query === undefined) {
+            logger.trace('>Default', prefix + sel.name.value);
+            proj[prefix + sel.name.value] = 1;
+          } else if (def.query === null) {
+            logger.trace('>Ignored');
+          } else if (Array.isArray(def.query)) {
+            def.query.forEach((v) => {
+              logger.trace('>Simple array', prefix + v);
               proj[prefix + v] = 1;
-            }
-          };
-          if (def === null) {
-            logger.trace('>Ignore', sel.name.value);
-            return;
+            });
+          } else {
+            logger.trace('>Simple', prefix + def.query);
+            proj[prefix + def.query] = 1;
           }
-          if (!def) {
-            goDefault();
-            return;
-          }
-          if (typeof def === 'string') {
-            goSimple(def);
-            return;
-          }
-          if (Array.isArray(def)) {
-            goSimple(def);
-            return;
-          }
-          if (def.query) {
-            goSimple(def.query);
-          }
           if (def.recursive && sel.selectionSet) {
-            goDefault();
-          } else if (!def.query) {
-            logger.trace('>Ignored');
+            const typeRef = info.schema.getType(type);
+            /* istanbul ignore if */
+            if (!typeRef) {
+              /* istanbul ignore next */
+              throw new Error('Type not found', type);
+            }
+            logger.trace('typeRef', typeRef.toString());
+            const field = typeRef.getFields()[sel.name.value];
+            /* istanbul ignore if */
+            if (!field) {
+              /* istanbul ignore next */
+              throw new Error('Field not found', sel.name.value);
+            }
+            const nextTypeRef = field.type;
+            logger.trace('nextTypeRef', nextTypeRef.toString());
+            const core = stripType(nextTypeRef);
+            logger.trace('Recursive', core);
+            Object.assign(proj, gen(root, sel, core));
           }
@@ -93,0 +71,0 @@ return;

src/resolver.js

 const _ = require('lodash');
+const validate = require('./validate');
 const logger = require('../logger');
@@ -6,19 +7,14 @@
   logger.trace('genResolver', config);
-  if (!config.proj) {
-    return {};
-  }
-  const res = {};
-  Object.keys(config.proj).forEach((k) => {
-    const def = config.proj[k];
-    if (!def) {
-      return;
-    }
-    if (typeof def === 'string') {
-      res[k] = (v) => _.get(v, def);
-    } else if (def.select) {
-      res[k] = (v) => _.get(v, def.select);
-    }
-  });
-  logger.trace('Generated resolver', Object.keys(res));
+  const res = _.chain(config.proj)
+    .mapValues((v) => {
+      const { select } = validate(v);
+      if (select) {
+        return (parent) => _.get(parent, select);
+      }
+      return undefined;
+    })
+    .pickBy()
+    .value();
+  logger.trace('Generated resolver', _.keys(res));
   return res;
 };

tests/projection.test.js

@@ -129,6 +129,7 @@ const genProjection = require('../src/projection');
       _id: 0,
+      'wrap.field1': 1,
     });
   });
 
-  it('should project nested', () => {
+  it('should project object null', () => {
     expect.hasAssertions();
@@ -138,2 +139,19 @@ return expect(run({
         prefix: 'wrap.',
+        proj: {
+          field1: {
+            query: null,
+            select: 'x',
+          },
+        },
+      },
+    }, '{ obj { field1 } }')).resolves.toEqual({
+      _id: 0,
+    });
+  });
+
+  it('should not project nested if unset', () => {
+    expect.hasAssertions();
+    return expect(run({
+      Obj: {
+        prefix: 'wrap.',
         proj: { },
@@ -149,2 +167,23 @@ },
       _id: 0,
+      'wrap.field2': 1,
+    });
+  });
+
+  it('should project nested', () => {
+    expect.hasAssertions();
+    return expect(run({
+      Obj: {
+        prefix: 'wrap.',
+        proj: {
+          field2: true,
+        },
+      },
+      Foo: {
+        prefix: 'wrap2.',
+        proj: {
+          f1: 'foo',
+        },
+      },
+    }, '{ obj { field2 { f1 } } }')).resolves.toEqual({
+      _id: 0,
       'wrap2.foo': 1,
@@ -269,2 +308,7 @@ });
     return expect(run({
+      Obj: {
+        proj: {
+          field3: true,
+        },
+      },
       Father: {
@@ -299,2 +343,7 @@ prefix: 'wrap.',
     return expect(run({
+      Obj: {
+        proj: {
+          field3: true,
+        },
+      },
       Father: {
@@ -333,2 +382,7 @@ prefix: 'wrap.',
     return expect(run({
+      Obj: {
+        proj: {
+          field3: true,
+        },
+      },
       Father: {
@@ -335,0 +389,0 @@ prefix: 'wrap.',

No alert changes

Improved metrics

Total package byte prevSize

166507

increased by13.71%

Number of package files

19

increased by18.75%

Lines of code

959

increased by25.85%

Worsened metrics

Dev dependency count

7

increased by75%

No dependency changes