apollo-server-module-operation-store - npm Package Compare versions

Comparing version 1.3.2 to 1.3.3

dist/operationStore.js

@@ -16,3 +16,5 @@ "use strict";
         }
-        var ast = isString(operation) ? graphql_1.parse(operation) : operation;
+        var ast = isString(operation)
+            ? graphql_1.parse(operation)
+            : operation;
         var definitions = ast.definitions.filter(isOperationDefinition);
@@ -19,0 +21,0 @@ if (definitions.length === 0) {

package.json

 {
   "name": "apollo-server-module-operation-store",
-  "version": "1.3.2",
+  "version": "1.3.3",
   "description": "Persisted operation store module for Apollo GraphQL Servers",
@@ -27,6 +27,6 @@ "main": "dist/index.js",
   "devDependencies": {
-    "@types/graphql": "0.11.7"
+    "@types/graphql": "0.12.6"
   },
   "peerDependencies": {
-    "graphql": "^0.9.0 || ^0.10.1 || ^0.11.0 || ^0.12.0"
+    "graphql": "^0.9.0 || ^0.10.1 || ^0.11.0 || ^0.12.0 || ^0.13.0"
   },
@@ -33,0 +33,0 @@ "typings": "dist/index.d.ts",

src/operationStore.test.ts

 import 'mocha';
 
-import {
-  expect,
-} from 'chai';
+import { expect } from 'chai';
 
 import {
-    GraphQLSchema,
-    GraphQLObjectType,
-    GraphQLString,
-    GraphQLInt,
-    GraphQLNonNull,
-    print,
-    parse,
+  GraphQLSchema,
+  GraphQLObjectType,
+  GraphQLString,
+  GraphQLInt,
+  GraphQLNonNull,
+  print,
+  parse,
 } from 'graphql';
@@ -20,36 +18,36 @@
 const queryType = new GraphQLObjectType({
-    name: 'QueryType',
-    fields: {
-        testString: {
-            type: GraphQLString,
-            /*resolve() {
+  name: 'QueryType',
+  fields: {
+    testString: {
+      type: GraphQLString,
+      /*resolve() {
                 return 'it works';
             },*/
-        },
-        testRootValue: {
-            type: GraphQLString,
-            /*resolve(root) {
+    },
+    testRootValue: {
+      type: GraphQLString,
+      /*resolve(root) {
                 return root + ' works';
             },*/
-        },
-        testContextValue: {
-            type: GraphQLString,
-            /*resolve(root, args, context) {
+    },
+    testContextValue: {
+      type: GraphQLString,
+      /*resolve(root, args, context) {
                 return context + ' works';
             },*/
-        },
-        testArgumentValue: {
-            type: GraphQLInt,
-            /*resolve(root, args, context) {
+    },
+    testArgumentValue: {
+      type: GraphQLInt,
+      /*resolve(root, args, context) {
                 return args['base'] + 5;
             },*/
-            args: {
-                base: { type: new GraphQLNonNull(GraphQLInt) },
-            },
-        },
+      args: {
+        base: { type: new GraphQLNonNull(GraphQLInt) },
+      },
     },
+  },
 });
 
 const schema = new GraphQLSchema({
-    query: queryType,
+  query: queryType,
 });
@@ -59,47 +57,47 @@
   it('can store a query and return its ast', () => {
-      const query = `query testquery{ testString }`;
-      const expected = `query testquery {\n  testString\n}\n`;
+    const query = `query testquery{ testString }`;
+    const expected = `query testquery {\n  testString\n}\n`;
 
-      const store = new OperationStore(schema);
-      store.put(query);
+    const store = new OperationStore(schema);
+    store.put(query);
 
-      return expect(print(store.get('testquery'))).to.deep.equal(expected);
+    return expect(print(store.get('testquery'))).to.deep.equal(expected);
   });
 
   it('can store a Document and return its ast', () => {
-      const query = `query testquery{ testString }`;
-      const expected = `query testquery {\n  testString\n}\n`;
+    const query = `query testquery{ testString }`;
+    const expected = `query testquery {\n  testString\n}\n`;
 
-      const store = new OperationStore(schema);
-      store.put(parse(query));
+    const store = new OperationStore(schema);
+    store.put(parse(query));
 
-      return expect(print(store.get('testquery'))).to.deep.equal(expected);
+    return expect(print(store.get('testquery'))).to.deep.equal(expected);
   });
 
   it('can store queries and return them with getMap', () => {
-      const query = `query testquery{ testString }`;
-      const query2 = `query testquery2{ testRootValue }`;
+    const query = `query testquery{ testString }`;
+    const query2 = `query testquery2{ testRootValue }`;
 
-      const store = new OperationStore(schema);
-      store.put(query);
-      store.put(query2);
-      return expect(store.getMap().size).to.equal(2);
+    const store = new OperationStore(schema);
+    store.put(query);
+    store.put(query2);
+    return expect(store.getMap().size).to.equal(2);
   });
 
   it('throws a parse error if the query is invalid', () => {
-      const query = `query testquery{ testString`;
+    const query = `query testquery{ testString`;
 
-      const store = new OperationStore(schema);
-      return expect(() => store.put(query)).to.throw(/Syntax Error/);
+    const store = new OperationStore(schema);
+    return expect(() => store.put(query)).to.throw(/Syntax Error/);
   });
 
   it('throws a validation error if the query is invalid', () => {
-      const query = `query testquery { testStrin }`;
+    const query = `query testquery { testStrin }`;
 
-      const store = new OperationStore(schema);
-      return expect(() => store.put(query)).to.throw(/Cannot query field/);
+    const store = new OperationStore(schema);
+    return expect(() => store.put(query)).to.throw(/Cannot query field/);
   });
 
   it('throws an error if there is more than one query or mutation', () => {
-      const query = `
+    const query = `
         query Q1{ testString }
@@ -109,8 +107,10 @@ query Q2{ t2: testString }
 
-      const store = new OperationStore(schema);
-      return expect(() => store.put(query)).to.throw(/OperationDefinitionNode must contain only one definition/);
+    const store = new OperationStore(schema);
+    return expect(() => store.put(query)).to.throw(
+      /OperationDefinitionNode must contain only one definition/,
+    );
   });
 
   it('throws an error if there is no operationDefinition found', () => {
-      const query = `
+    const query = `
         schema {
@@ -121,16 +121,16 @@ query: Q
 
-      const store = new OperationStore(schema);
+    const store = new OperationStore(schema);
 
-      return expect(() => store.put(query)).to.throw(/must contain at least/);
+    return expect(() => store.put(query)).to.throw(/must contain at least/);
   });
 
   it('can delete stored operations', () => {
-      const query = `query testquery{ testString }`;
+    const query = `query testquery{ testString }`;
 
-      const store = new OperationStore(schema);
-      store.put(query);
-      store.delete('testquery');
+    const store = new OperationStore(schema);
+    store.put(query);
+    store.delete('testquery');
 
-      return expect(store.get('testquery')).to.be.undefined;
+    return expect(store.get('testquery')).to.be.undefined;
   });
 });

src/operationStore.ts

@@ -20,3 +20,5 @@ import {
   public put(operation: string | DocumentNode): void {
-    function isOperationDefinition(definition): definition is OperationDefinitionNode {
+    function isOperationDefinition(
+      definition,
+    ): definition is OperationDefinitionNode {
       return definition.kind === Kind.OPERATION_DEFINITION;
@@ -29,10 +31,18 @@ }
 
-    const ast = isString(operation) ? parse(operation as string) : operation as DocumentNode;
+    const ast = isString(operation)
+      ? parse(operation as string)
+      : (operation as DocumentNode);
 
-    const definitions = ast.definitions.filter(isOperationDefinition) as OperationDefinitionNode[];
+    const definitions = ast.definitions.filter(
+      isOperationDefinition,
+    ) as OperationDefinitionNode[];
     if (definitions.length === 0) {
-      throw new Error('OperationDefinitionNode must contain at least one definition');
+      throw new Error(
+        'OperationDefinitionNode must contain at least one definition',
+      );
     }
     if (definitions.length > 1) {
-      throw new Error('OperationDefinitionNode must contain only one definition');
+      throw new Error(
+        'OperationDefinitionNode must contain only one definition',
+      );
     }
@@ -42,3 +52,3 @@
     if (validationErrors.length > 0) {
-      const messages = validationErrors.map((e) => e.message);
+      const messages = validationErrors.map(e => e.message);
       const err = new Error(`Validation Errors:\n${messages.join('\n')}`);
@@ -45,0 +55,0 @@ err['originalErrors'] = validationErrors;

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

New author

Supply chain risk

A new npm collaborator published a version of the package for the first time. New collaborators are usually benign additions to a project, but do indicate a change to the security surface area of a package.

Found 1 instance in 1 package

Improved metrics

Lines of code

228

increased by5.56%

Number of medium supply chain risk alerts

0

decreased by-100%

Worsened metrics

Total package byte prevSize

10862

decreased by-0.65%

No dependency changes