@envelop/generic-auth 4.3.0 → 4.3.1-alpha-72027859.0

package/README.md

@@ -25,11 +25,11 @@ Then, define your authentication methods:
 Use this method to only extract the user from the context, with any custom code, for example:
 
 ```ts
-import { ResolveUserFn } from '@envelop/generic-auth';
+import { ResolveUserFn } from '@envelop/generic-auth'
 
 type UserType = {
-  id: string;
-};
+  id: string
+}
 
 const resolveUserFn: ResolveUserFn<UserType> = async context => {
   // Here you can implement any custom sync/async code, and use the context built so far in Envelop and the HTTP request
@@ -38,15 +38,15 @@ const resolveUserFn: ResolveUserFn<UserType> = async context => {
   // Make sure to either return `null` or the user object.
 
   try {
-    const user = await context.authApi.authenticateUser(context.req.headers.authorization);
+    const user = await context.authApi.authenticateUser(context.req.headers.authorization)
 
-    return user;
+    return user
   } catch (e) {
-    console.error('Failed to validate token');
+    console.error('Failed to validate token')
 
-    return null;
+    return null
   }
-};
+}
 ```
 
 2. Define an optional validation method by implementing `validateUser`:
@@ -54,18 +54,18 @@ const resolveUserFn: ResolveUserFn<UserType> = async context => {
 This method is optional; the default method will just verify the value returned by `resolveUser` and throw an error in case of a false value (`false | null | undefined`).
 
 ```ts
-import { ValidateUserFn } from '@envelop/generic-auth';
+import { ValidateUserFn } from '@envelop/generic-auth'
 
-const validateUser: ValidateUserFn<UserType> = (params) => {
+const validateUser: ValidateUserFn<UserType> = params => {
   // Here you can implement any custom to check if the user is valid and have access to the server.
   // This method is being triggered in different flows, based on the mode you chose to implement.
 
   // If you are using the `protect-auth-directive` mode, you'll also get 2 additional parameters: the resolver parameters as object and the DirectiveNode of the auth directive.
 
   if (!user) {
-    throw new Error(`Unauthenticated!`);
+    throw new Error(`Unauthenticated!`)
   }
-};
+}
 ```
 
 Now, configure your plugin based on the mode you wish to use:
@@ -77,18 +77,18 @@ This mode offers complete protection for the entire API. It protects your entire
 To setup this mode, use the following config:
 
 ```ts
-import { envelop } from '@envelop/core';
-import { useGenericAuth, ResolveUserFn, ValidateUserFn } from '@envelop/generic-auth';
+import { envelop } from '@envelop/core'
+import { useGenericAuth, ResolveUserFn, ValidateUserFn } from '@envelop/generic-auth'
 
 type UserType = {
-  id: string;
-};
+  id: string
+}
 const resolveUserFn: ResolveUserFn<UserType> = async context => {
   /* ... */
-};
-const validateUser: ValidateUserFn<UserType> = (params) => {
+}
+const validateUser: ValidateUserFn<UserType> = params => {
   /* ... */
-};
+}
 
 const getEnveloped = envelop({
   plugins: [
@@ -96,10 +96,10 @@ const getEnveloped = envelop({
     useGenericAuth({
       resolveUserFn,
       validateUser,
-      mode: 'protect-all',
-    }),
-  ],
-});
+      mode: 'protect-all'
+    })
+  ]
+})
 ```
 
 ##### Allow unauthenticated access for specific fields using a field `directive`
@@ -123,7 +123,7 @@ type Query {
 ##### Allow unauthenticated access for specific fields using a field extension
 
 ```typescript
-import { GraphQLObjectType, GraphQLInt } from 'graphql';
+import { GraphQLObjectType, GraphQLInt } from 'graphql'
 
 const GraphQLQueryType = new GraphQLObjectType({
   name: 'Query',
@@ -132,11 +132,11 @@ const GraphQLQueryType = new GraphQLObjectType({
       type: GraphQLInt,
       resolve: () => 1,
       extensions: {
-        skipAuth: true,
-      },
-    },
-  },
-});
+        skipAuth: true
+      }
+    }
+  }
+})
 ```
 
 > If you want to use a different directive for authentication, you can use the `directiveOrExtensionFieldName` configuration to customize it.
@@ -146,18 +146,18 @@ const GraphQLQueryType = new GraphQLObjectType({
 This mode uses the plugin to inject the authenticated user into the `context`, and later you can verify it in your resolvers.
 
 ```ts
-import { envelop } from '@envelop/core';
-import { useGenericAuth, ResolveUserFn, ValidateUserFn } from '@envelop/generic-auth';
+import { envelop } from '@envelop/core'
+import { useGenericAuth, ResolveUserFn, ValidateUserFn } from '@envelop/generic-auth'
 
 type UserType = {
-  id: string;
-};
+  id: string
+}
 const resolveUserFn: ResolveUserFn<UserType> = async context => {
   /* ... */
-};
-const validateUser: ValidateUserFn<UserType> = async (params) => {
+}
+const validateUser: ValidateUserFn<UserType> = async params => {
   /* ... */
-};
+}
 
 const getEnveloped = envelop({
   plugins: [
@@ -165,10 +165,10 @@ const getEnveloped = envelop({
     useGenericAuth({
       resolveUserFn,
       validateUser,
-      mode: 'resolve-only',
-    }),
-  ],
-});
+      mode: 'resolve-only'
+    })
+  ]
+})
 ```
 
 Then, in your resolvers, you can execute the check method based on your needs:
@@ -177,13 +177,13 @@ Then, in your resolvers, you can execute the check method based on your needs:
 const resolvers = {
   Query: {
     me: async (root, args, context) => {
-      await context.validateUser();
-      const currentUser = context.currentUser;
+      await context.validateUser()
+      const currentUser = context.currentUser
 
-      return currentUser;
-    },
-  },
-};
+      return currentUser
+    }
+  }
+}
 ```
 
 #### Option #3 - `protect-granular`
@@ -191,18 +191,18 @@ const resolvers = {
 This mode is similar to option #2, but it uses the `@auth` SDL directive or `auth` field extension for protecting specific GraphQL fields.
 
 ```ts
-import { envelop } from '@envelop/core';
-import { useGenericAuth, ResolveUserFn, ValidateUserFn } from '@envelop/generic-auth';
+import { envelop } from '@envelop/core'
+import { useGenericAuth, ResolveUserFn, ValidateUserFn } from '@envelop/generic-auth'
 
 type UserType = {
-  id: string;
-};
+  id: string
+}
 const resolveUserFn: ResolveUserFn<UserType> = async context => {
   /* ... */
-};
-const validateUser: ValidateUserFn<UserType> = (params) => {
+}
+const validateUser: ValidateUserFn<UserType> = params => {
   /* ... */
-};
+}
 
 const getEnveloped = envelop({
   plugins: [
@@ -210,10 +210,10 @@ const getEnveloped = envelop({
     useGenericAuth({
       resolveUserFn,
       validateUser,
-      mode: 'protect-granular',
-    }),
-  ],
-});
+      mode: 'protect-granular'
+    })
+  ]
+})
 ```
 
 ##### Protect a field using a field `directive`
@@ -237,7 +237,7 @@ type Query {
 ##### Protect a field using a field extension
 
 ```typescript
-import { GraphQLObjectType, GraphQLInt } from 'graphql';
+import { GraphQLObjectType, GraphQLInt } from 'graphql'
 
 const GraphQLQueryType = new GraphQLObjectType({
   name: 'Query',
@@ -246,11 +246,11 @@ const GraphQLQueryType = new GraphQLObjectType({
       type: GraphQLInt,
       resolve: () => 1,
       extensions: {
-        auth: true,
-      },
-    },
-  },
-});
+        auth: true
+      }
+    }
+  }
+})
 ```
 
 > If you are using a different field extension for authentication, you can pass `directiveOrExtensionFieldName` configuration to customize it.
@@ -260,17 +260,17 @@ const GraphQLQueryType = new GraphQLObjectType({
 You can also specify a custom `validateUser` function and get access to a handy object while using the `protect-all` and `protect-granular` mode:
 
 ```ts
-import { GraphQLError } from 'graphql';
-import { ValidateUserFn } from '@envelop/generic-auth';
+import { GraphQLError } from 'graphql'
+import { ValidateUserFn } from '@envelop/generic-auth'
 
 const validateUser: ValidateUserFn<UserType> = async ({ user }) => {
   // Now you can use the 3rd parameter to implement custom logic for user validation, with access
   // to the resolver data and information.
 
   if (!user) {
-    return new GraphQLError(`Unauthenticated.`);
+    return new GraphQLError(`Unauthenticated.`)
   }
-};
+}
 ```
 
 And it's also possible to add custom parameters to your `@auth` directive. Here's an example for adding role-aware authentication:
@@ -287,21 +287,21 @@ directive @auth(role: Role!) on FIELD_DEFINITION
 Then, you use the `directiveNode` parameter to check the arguments:
 
 ```ts
-import { ValidateUserFn } from '@envelop/generic-auth';
+import { ValidateUserFn } from '@envelop/generic-auth'
 
 const validateUser: ValidateUserFn<UserType> = async ({ user, fieldAuthDirectiveNode }) => {
   // Now you can use the 3rd parameter to implement custom logic for user validation, with access
   // to the resolver data and information.
 
   if (!user) {
-    throw new Error(`Unauthenticated!`);
+    throw new Error(`Unauthenticated!`)
   }
 
-  const valueNode = fieldAuthDirectiveNode.arguments.find(arg => arg.name.value === 'role').value as EnumValueNode;
-  const role = valueNode.value;
+  const valueNode = fieldAuthDirectiveNode.arguments.find(arg => arg.name.value === 'role').value as EnumValueNode
+  const role = valueNode.value
 
   if (role !== user.role) {
-    throw new Error(`No permissions!`);
+    throw new Error(`No permissions!`)
   }
-};
+}
 ```

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@envelop/generic-auth",
-  "version": "4.3.0",
+  "version": "4.3.1-alpha-72027859.0",
   "sideEffects": false,
   "peerDependencies": {
-    "@envelop/core": "^2.4.0",
+    "@envelop/core": "2.4.1-alpha-72027859.0",
     "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0"
   },
   "dependencies": {
-    "@envelop/extended-validation": "^1.7.0"
+    "@envelop/extended-validation": "1.7.1-alpha-72027859.0"
   },
   "repository": {
     "type": "git",