fix: remove debug logs

fix(update_profile): changing password if not signed up via basic auth

Makefile

@@ -10,7 +10,16 @@ build-dashboard:
 clean:
 	rm -rf build
 test:
-	rm -rf server/test/test.db && rm -rf test.db && cd server && go clean --testcache && go test -p 1 -v ./test
+	rm -rf server/test/test.db && rm -rf test.db && cd server && go clean --testcache && TEST_DBS="sqlite" go test -p 1 -v ./test
+test-all-db:
+	rm -rf server/test/test.db && rm -rf test.db
+	docker run -d --name authorizer_scylla_db -p 9042:9042 scylladb/scylla
+	docker run -d --name authorizer_mongodb_db -p 27017:27017 mongo:4.4.15
+	docker run -d --name authorizer_arangodb -p 8529:8529 -e ARANGO_NO_AUTH=1 arangodb/arangodb:3.8.4
+	cd server && go clean --testcache && TEST_DBS="sqlite,mongodb,arangodb,scylladb" go test -p 1 -v ./test
+	docker rm -vf authorizer_mongodb_db
+	docker rm -vf authorizer_scylla_db
+	docker rm -vf authorizer_arangodb
 generate:
 	cd server && go get github.com/99designs/gqlgen/cmd@v0.14.0 && go run github.com/99designs/gqlgen generate
 	

app/package-lock.json

@@ -9,7 +9,7 @@
 			"version": "1.0.0",
 			"license": "ISC",
 			"dependencies": {
-				"@authorizerdev/authorizer-react": "^0.24.0-beta.1",
+				"@authorizerdev/authorizer-react": "^0.25.0",
 				"@types/react": "^17.0.15",
 				"@types/react-dom": "^17.0.9",
 				"esbuild": "^0.12.17",
@@ -26,9 +26,9 @@
 			}
 		},
 		"node_modules/@authorizerdev/authorizer-js": {
-			"version": "0.13.0-beta.2",
+			"version": "0.14.0",
-			"resolved": "https://registry.npmjs.org/@authorizerdev/authorizer-js/-/authorizer-js-0.13.0-beta.2.tgz",
+			"resolved": "https://registry.npmjs.org/@authorizerdev/authorizer-js/-/authorizer-js-0.14.0.tgz",
-			"integrity": "sha512-3K3Qew/npD375DQdJnYb43aWVOU7giG2+8sHOjy8aXhZ+GlQQ8cGu54lozFYUMDcM1HjQU2N53xLmneONPepSw==",
+			"integrity": "sha512-cpeeFrmG623QPLn+nf+ACHayZYqW8xokIidGikeboBDJtuAAQB50a54/7HwLHriG2FB7WvPuHQ/9LFFX//N1lg==",
 			"dependencies": {
 				"node-fetch": "^2.6.1"
 			},
@@ -37,11 +37,11 @@
 			}
 		},
 		"node_modules/@authorizerdev/authorizer-react": {
-			"version": "0.24.0-beta.1",
+			"version": "0.25.0",
-			"resolved": "https://registry.npmjs.org/@authorizerdev/authorizer-react/-/authorizer-react-0.24.0-beta.1.tgz",
+			"resolved": "https://registry.npmjs.org/@authorizerdev/authorizer-react/-/authorizer-react-0.25.0.tgz",
-			"integrity": "sha512-S/Oqc24EfotbrABuv379i/3uCfQPYJQqXrOU9d8AytF++pzG/2dcoIoaMbWZQkATR3m6a5AnhpG6bIB+4NbrUQ==",
+			"integrity": "sha512-Dt2rZf+cGCVb8dqcJ/9l8Trx+QeXnTdfhER6r/cq0iOnFC9MqWzQPB3RgrlUoMLHtZvKNDXIk1HvfD5hSX9lhw==",
 			"dependencies": {
-				"@authorizerdev/authorizer-js": "^0.13.0-beta.2",
+				"@authorizerdev/authorizer-js": "^0.14.0",
 				"final-form": "^4.20.2",
 				"react-final-form": "^6.5.3",
 				"styled-components": "^5.3.0"
@@ -852,19 +852,19 @@
 	},
 	"dependencies": {
 		"@authorizerdev/authorizer-js": {
-			"version": "0.13.0-beta.2",
+			"version": "0.14.0",
-			"resolved": "https://registry.npmjs.org/@authorizerdev/authorizer-js/-/authorizer-js-0.13.0-beta.2.tgz",
+			"resolved": "https://registry.npmjs.org/@authorizerdev/authorizer-js/-/authorizer-js-0.14.0.tgz",
-			"integrity": "sha512-3K3Qew/npD375DQdJnYb43aWVOU7giG2+8sHOjy8aXhZ+GlQQ8cGu54lozFYUMDcM1HjQU2N53xLmneONPepSw==",
+			"integrity": "sha512-cpeeFrmG623QPLn+nf+ACHayZYqW8xokIidGikeboBDJtuAAQB50a54/7HwLHriG2FB7WvPuHQ/9LFFX//N1lg==",
 			"requires": {
 				"node-fetch": "^2.6.1"
 			}
 		},
 		"@authorizerdev/authorizer-react": {
-			"version": "0.24.0-beta.1",
+			"version": "0.25.0",
-			"resolved": "https://registry.npmjs.org/@authorizerdev/authorizer-react/-/authorizer-react-0.24.0-beta.1.tgz",
+			"resolved": "https://registry.npmjs.org/@authorizerdev/authorizer-react/-/authorizer-react-0.25.0.tgz",
-			"integrity": "sha512-S/Oqc24EfotbrABuv379i/3uCfQPYJQqXrOU9d8AytF++pzG/2dcoIoaMbWZQkATR3m6a5AnhpG6bIB+4NbrUQ==",
+			"integrity": "sha512-Dt2rZf+cGCVb8dqcJ/9l8Trx+QeXnTdfhER6r/cq0iOnFC9MqWzQPB3RgrlUoMLHtZvKNDXIk1HvfD5hSX9lhw==",
 			"requires": {
-				"@authorizerdev/authorizer-js": "^0.13.0-beta.2",
+				"@authorizerdev/authorizer-js": "^0.14.0",
 				"final-form": "^4.20.2",
 				"react-final-form": "^6.5.3",
 				"styled-components": "^5.3.0"

app/package.json

@@ -11,7 +11,7 @@
 	"author": "Lakhan Samani",
 	"license": "ISC",
 	"dependencies": {
-		"@authorizerdev/authorizer-react": "^0.24.0-beta.1",
+		"@authorizerdev/authorizer-react": "^0.25.0",
 		"@types/react": "^17.0.15",
 		"@types/react-dom": "^17.0.9",
 		"esbuild": "^0.12.17",

dashboard/package-lock.json

@@ -2529,7 +2529,8 @@
 		"@chakra-ui/css-reset": {
 			"version": "1.1.1",
 			"resolved": "https://registry.npmjs.org/@chakra-ui/css-reset/-/css-reset-1.1.1.tgz",
-			"integrity": "sha512-+KNNHL4OWqeKia5SL858K3Qbd8WxMij9mWIilBzLD4j2KFrl/+aWFw8syMKth3NmgIibrjsljo+PU3fy2o50dg=="
+			"integrity": "sha512-+KNNHL4OWqeKia5SL858K3Qbd8WxMij9mWIilBzLD4j2KFrl/+aWFw8syMKth3NmgIibrjsljo+PU3fy2o50dg==",
+			"requires": {}
 		},
 		"@chakra-ui/descendant": {
 			"version": "2.1.1",
@@ -3133,7 +3134,8 @@
 		"@graphql-typed-document-node/core": {
 			"version": "3.1.1",
 			"resolved": "https://registry.npmjs.org/@graphql-typed-document-node/core/-/core-3.1.1.tgz",
-			"integrity": "sha512-NQ17ii0rK1b34VZonlmT2QMJFI70m0TRwbknO/ihlbatXyaktDhN/98vBiUU6kNBPljqGqyIrl2T4nY2RpFANg=="
+			"integrity": "sha512-NQ17ii0rK1b34VZonlmT2QMJFI70m0TRwbknO/ihlbatXyaktDhN/98vBiUU6kNBPljqGqyIrl2T4nY2RpFANg==",
+			"requires": {}
 		},
 		"@popperjs/core": {
 			"version": "2.11.0",
@@ -3843,7 +3845,8 @@
 		"react-icons": {
 			"version": "4.3.1",
 			"resolved": "https://registry.npmjs.org/react-icons/-/react-icons-4.3.1.tgz",
-			"integrity": "sha512-cB10MXLTs3gVuXimblAdI71jrJx8njrJZmNMEMC+sQu5B/BIOmlsAjskdqpn81y8UBVEGuHODd7/ci5DvoSzTQ=="
+			"integrity": "sha512-cB10MXLTs3gVuXimblAdI71jrJx8njrJZmNMEMC+sQu5B/BIOmlsAjskdqpn81y8UBVEGuHODd7/ci5DvoSzTQ==",
+			"requires": {}
 		},
 		"react-is": {
 			"version": "16.13.1",
@@ -4029,7 +4032,8 @@
 		"use-callback-ref": {
 			"version": "1.2.5",
 			"resolved": "https://registry.npmjs.org/use-callback-ref/-/use-callback-ref-1.2.5.tgz",
-			"integrity": "sha512-gN3vgMISAgacF7sqsLPByqoePooY3n2emTH59Ur5d/M8eg4WTWu1xp8i8DHjohftIyEx0S08RiYxbffr4j8Peg=="
+			"integrity": "sha512-gN3vgMISAgacF7sqsLPByqoePooY3n2emTH59Ur5d/M8eg4WTWu1xp8i8DHjohftIyEx0S08RiYxbffr4j8Peg==",
+			"requires": {}
 		},
 		"use-sidecar": {
 			"version": "1.0.5",

dashboard/src/components/EnvComponents/Features.tsx

@@ -71,6 +71,18 @@ const Features = ({ variables, setVariables }: any) => {
 						/>
 					</Flex>
 				</Flex>
+				<Flex>
+					<Flex w="100%" justifyContent="start" alignItems="center">
+						<Text fontSize="sm">Disable Strong Password:</Text>
+					</Flex>
+					<Flex justifyContent="start" mb={3}>
+						<InputField
+							variables={variables}
+							setVariables={setVariables}
+							inputType={SwitchInputType.DISABLE_STRONG_PASSWORD}
+						/>
+					</Flex>
+				</Flex>
 			</Stack>
 		</div>
 	);

dashboard/src/constants.ts

@@ -67,6 +67,7 @@ export const SwitchInputType = {
 	DISABLE_BASIC_AUTHENTICATION: 'DISABLE_BASIC_AUTHENTICATION',
 	DISABLE_SIGN_UP: 'DISABLE_SIGN_UP',
 	DISABLE_REDIS_FOR_ENV: 'DISABLE_REDIS_FOR_ENV',
+	DISABLE_STRONG_PASSWORD: 'DISABLE_STRONG_PASSWORD',
 };
 
 export const DateInputType = {
@@ -131,6 +132,7 @@ export interface envVarTypes {
 	DISABLE_EMAIL_VERIFICATION: boolean;
 	DISABLE_BASIC_AUTHENTICATION: boolean;
 	DISABLE_SIGN_UP: boolean;
+	DISABLE_STRONG_PASSWORD: boolean;
 	OLD_ADMIN_SECRET: string;
 	DATABASE_NAME: string;
 	DATABASE_TYPE: string;

dashboard/src/graphql/queries/index.ts

@@ -53,6 +53,7 @@ export const EnvVariablesQuery = `
       DISABLE_EMAIL_VERIFICATION,
       DISABLE_BASIC_AUTHENTICATION,
       DISABLE_SIGN_UP,
+      DISABLE_STRONG_PASSWORD,
       DISABLE_REDIS_FOR_ENV,
       CUSTOM_ACCESS_TOKEN_SCRIPT,
       DATABASE_NAME,

dashboard/src/pages/Environment.tsx

@@ -74,6 +74,7 @@ const Environment = () => {
 		DISABLE_EMAIL_VERIFICATION: false,
 		DISABLE_BASIC_AUTHENTICATION: false,
 		DISABLE_SIGN_UP: false,
+		DISABLE_STRONG_PASSWORD: false,
 		OLD_ADMIN_SECRET: '',
 		DATABASE_NAME: '',
 		DATABASE_TYPE: '',

server/constants/auth_methods.go

@@ -0,0 +1,18 @@
+package constants
+
+const (
+	// AuthRecipeMethodBasicAuth is the basic_auth auth method
+	AuthRecipeMethodBasicAuth = "basic_auth"
+	// AuthRecipeMethodMagicLinkLogin is the magic_link_login auth method
+	AuthRecipeMethodMagicLinkLogin = "magic_link_login"
+	// AuthRecipeMethodGoogle is the google auth method
+	AuthRecipeMethodGoogle = "google"
+	// AuthRecipeMethodGithub is the github auth method
+	AuthRecipeMethodGithub = "github"
+	// AuthRecipeMethodFacebook is the facebook auth method
+	AuthRecipeMethodFacebook = "facebook"
+	// AuthRecipeMethodLinkedin is the linkedin auth method
+	AuthRecipeMethodLinkedIn = "linkedin"
+	// AuthRecipeMethodApple is the apple auth method
+	AuthRecipeMethodApple = "apple"
+)

server/constants/db_types.go

@@ -23,4 +23,6 @@ const (
 	DbTypeScyllaDB = "scylladb"
 	// DbTypeCockroachDB is the cockroach database type
 	DbTypeCockroachDB = "cockroachdb"
+	// DbTypePlanetScaleDB is the planetscale database type
+	DbTypePlanetScaleDB = "planetscale"
 )

server/constants/env.go

@@ -115,6 +115,8 @@ const (
 	EnvKeyDisableSignUp = "DISABLE_SIGN_UP"
 	// EnvKeyDisableRedisForEnv key for env variable DISABLE_REDIS_FOR_ENV
 	EnvKeyDisableRedisForEnv = "DISABLE_REDIS_FOR_ENV"
+	// EnvKeyDisableStrongPassword key for env variable DISABLE_STRONG_PASSWORD
+	EnvKeyDisableStrongPassword = "DISABLE_STRONG_PASSWORD"
 
 	// Slice variables
 	// EnvKeyRoles key for env variable ROLES

server/constants/oauth_info_urls.go

@@ -8,6 +8,9 @@ const (
 	FacebookUserInfoURL = "https://graph.facebook.com/me?fields=id,first_name,last_name,name,email,picture&access_token="
 	// Ref: https://docs.github.com/en/developers/apps/building-github-apps/identifying-and-authorizing-users-for-github-apps#3-your-github-app-accesses-the-api-with-the-users-access-token
 	GithubUserInfoURL = "https://api.github.com/user"
+	// Get github user emails when user info email is empty Ref: https://stackoverflow.com/a/35387123
+	GithubUserEmails = "https://api/github.com/user/emails"
+
 	// Ref: https://docs.microsoft.com/en-us/linkedin/shared/integrations/people/profile-api
 	LinkedInUserInfoURL = "https://api.linkedin.com/v2/me?projection=(id,localizedFirstName,localizedLastName,emailAddress,profilePicture(displayImage~:playableStreams))"
 	LinkedInEmailURL    = "https://api.linkedin.com/v2/emailAddress?q=members&projection=(elements*(handle~))"

server/constants/signup_methods.go

@@ -1,18 +0,0 @@
-package constants
-
-const (
-	// SignupMethodBasicAuth is the basic_auth signup method
-	SignupMethodBasicAuth = "basic_auth"
-	// SignupMethodMagicLinkLogin is the magic_link_login signup method
-	SignupMethodMagicLinkLogin = "magic_link_login"
-	// SignupMethodGoogle is the google signup method
-	SignupMethodGoogle = "google"
-	// SignupMethodGithub is the github signup method
-	SignupMethodGithub = "github"
-	// SignupMethodFacebook is the facebook signup method
-	SignupMethodFacebook = "facebook"
-	// SignupMethodLinkedin is the linkedin signup method
-	SignupMethodLinkedIn = "linkedin"
-	// SignupMethodApple is the apple signup method
-	SignupMethodApple = "apple"
-)

server/constants/webhook_event.go

@@ -0,0 +1,18 @@
+package constants
+
+const (
+
+	// UserLoginWebhookEvent name for login event
+	UserLoginWebhookEvent = `user.login`
+	// UserCreatedWebhookEvent name for user creation event
+	// This is triggered when user entry is created but still not verified
+	UserCreatedWebhookEvent = `user.created`
+	// UserSignUpWebhookEvent name for signup event
+	UserSignUpWebhookEvent = `user.signup`
+	// UserAccessRevokedWebhookEvent name for user access revoke event
+	UserAccessRevokedWebhookEvent = `user.access_revoked`
+	// UserAccessEnabledWebhookEvent name for user access enable event
+	UserAccessEnabledWebhookEvent = `user.access_enabled`
+	// UserDeletedWebhookEvent name for user deleted event
+	UserDeletedWebhookEvent = `user.deleted`
+)

server/db/models/email_templates.go

@@ -0,0 +1,33 @@
+package models
+
+import (
+	"strings"
+
+	"github.com/authorizerdev/authorizer/server/graph/model"
+	"github.com/authorizerdev/authorizer/server/refs"
+)
+
+// EmailTemplate model for database
+type EmailTemplate struct {
+	Key       string `json:"_key,omitempty" bson:"_key,omitempty" cql:"_key,omitempty"` // for arangodb
+	ID        string `gorm:"primaryKey;type:char(36)" json:"_id" bson:"_id" cql:"id"`
+	EventName string `gorm:"unique" json:"event_name" bson:"event_name" cql:"event_name"`
+	Template  string `gorm:"type:text" json:"template" bson:"template" cql:"template"`
+	CreatedAt int64  `json:"created_at" bson:"created_at" cql:"created_at"`
+	UpdatedAt int64  `json:"updated_at" bson:"updated_at" cql:"updated_at"`
+}
+
+// AsAPIEmailTemplate to return email template as graphql response object
+func (e *EmailTemplate) AsAPIEmailTemplate() *model.EmailTemplate {
+	id := e.ID
+	if strings.Contains(id, Collections.EmailTemplate+"/") {
+		id = strings.TrimPrefix(id, Collections.EmailTemplate+"/")
+	}
+	return &model.EmailTemplate{
+		ID:        id,
+		EventName: e.EventName,
+		Template:  e.Template,
+		CreatedAt: refs.NewInt64Ref(e.CreatedAt),
+		UpdatedAt: refs.NewInt64Ref(e.UpdatedAt),
+	}
+}

server/db/models/model.go

@@ -6,6 +6,9 @@ type CollectionList struct {
 	VerificationRequest string
 	Session             string
 	Env                 string
+	Webhook             string
+	WebhookLog          string
+	EmailTemplate       string
 }
 
 var (
@@ -17,5 +20,8 @@ var (
 		VerificationRequest: Prefix + "verification_requests",
 		Session:             Prefix + "sessions",
 		Env:                 Prefix + "env",
+		Webhook:             Prefix + "webhook",
+		WebhookLog:          Prefix + "webhook_log",
+		EmailTemplate:       Prefix + "email_template",
 	}
 )

server/db/models/session.go

@@ -6,8 +6,7 @@ package models
 type Session struct {
 	Key       string `json:"_key,omitempty" bson:"_key,omitempty" cql:"_key,omitempty"` // for arangodb
 	ID        string `gorm:"primaryKey;type:char(36)" json:"_id" bson:"_id" cql:"id"`
-	UserID    string `gorm:"type:char(36),index:" json:"user_id" bson:"user_id" cql:"user_id"`
+	UserID    string `gorm:"type:char(36)" json:"user_id" bson:"user_id" cql:"user_id"`
-	User      User   `gorm:"constraint:OnUpdate:CASCADE,OnDelete:CASCADE;" json:"-" bson:"-" cql:"-"`
 	UserAgent string `json:"user_agent" bson:"user_agent" cql:"user_agent"`
 	IP        string `json:"ip" bson:"ip" cql:"ip"`
 	CreatedAt int64  `json:"created_at" bson:"created_at" cql:"created_at"`

server/db/models/user.go

@@ -4,6 +4,7 @@ import (
 	"strings"
 
 	"github.com/authorizerdev/authorizer/server/graph/model"
+	"github.com/authorizerdev/authorizer/server/refs"
 )
 
 // Note: any change here should be reflected in providers/casandra/provider.go as it does not have model support in collection creation
@@ -35,11 +36,13 @@ type User struct {
 func (user *User) AsAPIUser() *model.User {
 	isEmailVerified := user.EmailVerifiedAt != nil
 	isPhoneVerified := user.PhoneNumberVerifiedAt != nil
-	email := user.Email
+
-	createdAt := user.CreatedAt
+	id := user.ID
-	updatedAt := user.UpdatedAt
+	if strings.Contains(id, Collections.WebhookLog+"/") {
+		id = strings.TrimPrefix(id, Collections.WebhookLog+"/")
+	}
 	return &model.User{
-		ID:                  user.ID,
+		ID:                  id,
 		Email:               user.Email,
 		EmailVerified:       isEmailVerified,
 		SignupMethods:       user.SignupMethods,
@@ -47,7 +50,7 @@ func (user *User) AsAPIUser() *model.User {
 		FamilyName:          user.FamilyName,
 		MiddleName:          user.MiddleName,
 		Nickname:            user.Nickname,
-		PreferredUsername:   &email,
+		PreferredUsername:   refs.NewStringRef(user.Email),
 		Gender:              user.Gender,
 		Birthdate:           user.Birthdate,
 		PhoneNumber:         user.PhoneNumber,
@@ -55,7 +58,7 @@ func (user *User) AsAPIUser() *model.User {
 		Picture:             user.Picture,
 		Roles:               strings.Split(user.Roles, ","),
 		RevokedTimestamp:    user.RevokedTimestamp,
-		CreatedAt:           &createdAt,
+		CreatedAt:           refs.NewInt64Ref(user.CreatedAt),
-		UpdatedAt:           &updatedAt,
+		UpdatedAt:           refs.NewInt64Ref(user.UpdatedAt),
 	}
 }

server/db/models/verification_requests.go

@@ -1,6 +1,11 @@
 package models
 
-import "github.com/authorizerdev/authorizer/server/graph/model"
+import (
+	"strings"
+
+	"github.com/authorizerdev/authorizer/server/graph/model"
+	"github.com/authorizerdev/authorizer/server/refs"
+)
 
 // Note: any change here should be reflected in providers/casandra/provider.go as it does not have model support in collection creation
 
@@ -19,23 +24,20 @@ type VerificationRequest struct {
 }
 
 func (v *VerificationRequest) AsAPIVerificationRequest() *model.VerificationRequest {
-	token := v.Token
+	id := v.ID
-	createdAt := v.CreatedAt
+	if strings.Contains(id, Collections.WebhookLog+"/") {
-	updatedAt := v.UpdatedAt
+		id = strings.TrimPrefix(id, Collections.WebhookLog+"/")
-	email := v.Email
+	}
-	nonce := v.Nonce
+
-	redirectURI := v.RedirectURI
-	expires := v.ExpiresAt
-	identifier := v.Identifier
 	return &model.VerificationRequest{
-		ID:          v.ID,
+		ID:          id,
-		Token:       &token,
+		Token:       refs.NewStringRef(v.Token),
-		Identifier:  &identifier,
+		Identifier:  refs.NewStringRef(v.Identifier),
-		Expires:     &expires,
+		Expires:     refs.NewInt64Ref(v.ExpiresAt),
-		Email:       &email,
+		Email:       refs.NewStringRef(v.Email),
-		Nonce:       &nonce,
+		Nonce:       refs.NewStringRef(v.Nonce),
-		RedirectURI: &redirectURI,
+		RedirectURI: refs.NewStringRef(v.RedirectURI),
-		CreatedAt:   &createdAt,
+		CreatedAt:   refs.NewInt64Ref(v.CreatedAt),
-		UpdatedAt:   &updatedAt,
+		UpdatedAt:   refs.NewInt64Ref(v.UpdatedAt),
 	}
 }

server/db/models/webhook.go

@@ -0,0 +1,44 @@
+package models
+
+import (
+	"encoding/json"
+	"strings"
+
+	"github.com/authorizerdev/authorizer/server/graph/model"
+	"github.com/authorizerdev/authorizer/server/refs"
+)
+
+// Note: any change here should be reflected in providers/casandra/provider.go as it does not have model support in collection creation
+
+// Webhook model for db
+type Webhook struct {
+	Key       string `json:"_key,omitempty" bson:"_key,omitempty" cql:"_key,omitempty"` // for arangodb
+	ID        string `gorm:"primaryKey;type:char(36)" json:"_id" bson:"_id" cql:"id"`
+	EventName string `gorm:"unique" json:"event_name" bson:"event_name" cql:"event_name"`
+	EndPoint  string `gorm:"type:text" json:"endpoint" bson:"endpoint" cql:"endpoint"`
+	Headers   string `gorm:"type:text" json:"headers" bson:"headers" cql:"headers"`
+	Enabled   bool   `json:"enabled" bson:"enabled" cql:"enabled"`
+	CreatedAt int64  `json:"created_at" bson:"created_at" cql:"created_at"`
+	UpdatedAt int64  `json:"updated_at" bson:"updated_at" cql:"updated_at"`
+}
+
+// AsAPIWebhook to return webhook as graphql response object
+func (w *Webhook) AsAPIWebhook() *model.Webhook {
+	headersMap := make(map[string]interface{})
+	json.Unmarshal([]byte(w.Headers), &headersMap)
+
+	id := w.ID
+	if strings.Contains(id, Collections.Webhook+"/") {
+		id = strings.TrimPrefix(id, Collections.Webhook+"/")
+	}
+
+	return &model.Webhook{
+		ID:        id,
+		EventName: refs.NewStringRef(w.EventName),
+		Endpoint:  refs.NewStringRef(w.EndPoint),
+		Headers:   headersMap,
+		Enabled:   refs.NewBoolRef(w.Enabled),
+		CreatedAt: refs.NewInt64Ref(w.CreatedAt),
+		UpdatedAt: refs.NewInt64Ref(w.UpdatedAt),
+	}
+}

server/db/models/webhook_log.go

@@ -0,0 +1,39 @@
+package models
+
+import (
+	"strings"
+
+	"github.com/authorizerdev/authorizer/server/graph/model"
+	"github.com/authorizerdev/authorizer/server/refs"
+)
+
+// Note: any change here should be reflected in providers/casandra/provider.go as it does not have model support in collection creation
+
+// WebhookLog model for db
+type WebhookLog struct {
+	Key        string `json:"_key,omitempty" bson:"_key,omitempty" cql:"_key,omitempty"` // for arangodb
+	ID         string `gorm:"primaryKey;type:char(36)" json:"_id" bson:"_id" cql:"id"`
+	HttpStatus int64  `json:"http_status" bson:"http_status" cql:"http_status"`
+	Response   string `gorm:"type:text" json:"response" bson:"response" cql:"response"`
+	Request    string `gorm:"type:text" json:"request" bson:"request" cql:"request"`
+	WebhookID  string `gorm:"type:char(36)" json:"webhook_id" bson:"webhook_id" cql:"webhook_id"`
+	CreatedAt  int64  `json:"created_at" bson:"created_at" cql:"created_at"`
+	UpdatedAt  int64  `json:"updated_at" bson:"updated_at" cql:"updated_at"`
+}
+
+// AsAPIWebhookLog to return webhook log as graphql response object
+func (w *WebhookLog) AsAPIWebhookLog() *model.WebhookLog {
+	id := w.ID
+	if strings.Contains(id, Collections.WebhookLog+"/") {
+		id = strings.TrimPrefix(id, Collections.WebhookLog+"/")
+	}
+	return &model.WebhookLog{
+		ID:         id,
+		HTTPStatus: refs.NewInt64Ref(w.HttpStatus),
+		Response:   refs.NewStringRef(w.Response),
+		Request:    refs.NewStringRef(w.Request),
+		WebhookID:  refs.NewStringRef(w.WebhookID),
+		CreatedAt:  refs.NewInt64Ref(w.CreatedAt),
+		UpdatedAt:  refs.NewInt64Ref(w.UpdatedAt),
+	}
+}

server/db/providers/arangodb/email_template.go

@@ -0,0 +1,151 @@
+package arangodb
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/arangodb/go-driver"
+	arangoDriver "github.com/arangodb/go-driver"
+	"github.com/authorizerdev/authorizer/server/db/models"
+	"github.com/authorizerdev/authorizer/server/graph/model"
+	"github.com/google/uuid"
+)
+
+// AddEmailTemplate to add EmailTemplate
+func (p *provider) AddEmailTemplate(ctx context.Context, emailTemplate models.EmailTemplate) (*model.EmailTemplate, error) {
+	if emailTemplate.ID == "" {
+		emailTemplate.ID = uuid.New().String()
+	}
+
+	emailTemplate.Key = emailTemplate.ID
+	emailTemplate.CreatedAt = time.Now().Unix()
+	emailTemplate.UpdatedAt = time.Now().Unix()
+
+	emailTemplateCollection, _ := p.db.Collection(ctx, models.Collections.EmailTemplate)
+	_, err := emailTemplateCollection.CreateDocument(ctx, emailTemplate)
+	if err != nil {
+		return nil, err
+	}
+	return emailTemplate.AsAPIEmailTemplate(), nil
+}
+
+// UpdateEmailTemplate to update EmailTemplate
+func (p *provider) UpdateEmailTemplate(ctx context.Context, emailTemplate models.EmailTemplate) (*model.EmailTemplate, error) {
+	emailTemplate.UpdatedAt = time.Now().Unix()
+
+	emailTemplateCollection, _ := p.db.Collection(ctx, models.Collections.EmailTemplate)
+	meta, err := emailTemplateCollection.UpdateDocument(ctx, emailTemplate.Key, emailTemplate)
+	if err != nil {
+		return nil, err
+	}
+
+	emailTemplate.Key = meta.Key
+	emailTemplate.ID = meta.ID.String()
+	return emailTemplate.AsAPIEmailTemplate(), nil
+}
+
+// ListEmailTemplates to list EmailTemplate
+func (p *provider) ListEmailTemplate(ctx context.Context, pagination model.Pagination) (*model.EmailTemplates, error) {
+	emailTemplates := []*model.EmailTemplate{}
+
+	query := fmt.Sprintf("FOR d in %s SORT d.created_at DESC LIMIT %d, %d RETURN d", models.Collections.EmailTemplate, pagination.Offset, pagination.Limit)
+
+	sctx := driver.WithQueryFullCount(ctx)
+	cursor, err := p.db.Query(sctx, query, nil)
+	if err != nil {
+		return nil, err
+	}
+	defer cursor.Close()
+
+	paginationClone := pagination
+	paginationClone.Total = cursor.Statistics().FullCount()
+
+	for {
+		var emailTemplate models.EmailTemplate
+		meta, err := cursor.ReadDocument(ctx, &emailTemplate)
+
+		if arangoDriver.IsNoMoreDocuments(err) {
+			break
+		} else if err != nil {
+			return nil, err
+		}
+
+		if meta.Key != "" {
+			emailTemplates = append(emailTemplates, emailTemplate.AsAPIEmailTemplate())
+		}
+	}
+
+	return &model.EmailTemplates{
+		Pagination:     &paginationClone,
+		EmailTemplates: emailTemplates,
+	}, nil
+}
+
+// GetEmailTemplateByID to get EmailTemplate by id
+func (p *provider) GetEmailTemplateByID(ctx context.Context, emailTemplateID string) (*model.EmailTemplate, error) {
+	var emailTemplate models.EmailTemplate
+	query := fmt.Sprintf("FOR d in %s FILTER d._key == @email_template_id RETURN d", models.Collections.EmailTemplate)
+	bindVars := map[string]interface{}{
+		"email_template_id": emailTemplateID,
+	}
+
+	cursor, err := p.db.Query(ctx, query, bindVars)
+	if err != nil {
+		return nil, err
+	}
+	defer cursor.Close()
+
+	for {
+		if !cursor.HasMore() {
+			if emailTemplate.Key == "" {
+				return nil, fmt.Errorf("email template not found")
+			}
+			break
+		}
+		_, err := cursor.ReadDocument(ctx, &emailTemplate)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return emailTemplate.AsAPIEmailTemplate(), nil
+}
+
+// GetEmailTemplateByEventName to get EmailTemplate by event_name
+func (p *provider) GetEmailTemplateByEventName(ctx context.Context, eventName string) (*model.EmailTemplate, error) {
+	var emailTemplate models.EmailTemplate
+	query := fmt.Sprintf("FOR d in %s FILTER d.event_name == @event_name RETURN d", models.Collections.EmailTemplate)
+	bindVars := map[string]interface{}{
+		"event_name": eventName,
+	}
+
+	cursor, err := p.db.Query(ctx, query, bindVars)
+	if err != nil {
+		return nil, err
+	}
+	defer cursor.Close()
+
+	for {
+		if !cursor.HasMore() {
+			if emailTemplate.Key == "" {
+				return nil, fmt.Errorf("email template not found")
+			}
+			break
+		}
+		_, err := cursor.ReadDocument(ctx, &emailTemplate)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return emailTemplate.AsAPIEmailTemplate(), nil
+}
+
+// DeleteEmailTemplate to delete EmailTemplate
+func (p *provider) DeleteEmailTemplate(ctx context.Context, emailTemplate *model.EmailTemplate) error {
+	eventTemplateCollection, _ := p.db.Collection(ctx, models.Collections.EmailTemplate)
+	_, err := eventTemplateCollection.RemoveDocument(ctx, emailTemplate.ID)
+	if err != nil {
+		return err
+	}
+	return nil
+}

server/db/providers/arangodb/env.go

@@ -1,6 +1,7 @@
 package arangodb
 
 import (
+	"context"
 	"fmt"
 	"time"
 
@@ -11,15 +12,15 @@ import (
 )
 
 // AddEnv to save environment information in database
-func (p *provider) AddEnv(env models.Env) (models.Env, error) {
+func (p *provider) AddEnv(ctx context.Context, env models.Env) (models.Env, error) {
 	if env.ID == "" {
 		env.ID = uuid.New().String()
 	}
 
 	env.CreatedAt = time.Now().Unix()
 	env.UpdatedAt = time.Now().Unix()
-	configCollection, _ := p.db.Collection(nil, models.Collections.Env)
+	configCollection, _ := p.db.Collection(ctx, models.Collections.Env)
-	meta, err := configCollection.CreateDocument(arangoDriver.WithOverwrite(nil), env)
+	meta, err := configCollection.CreateDocument(arangoDriver.WithOverwrite(ctx), env)
 	if err != nil {
 		return env, err
 	}
@@ -29,10 +30,10 @@ func (p *provider) AddEnv(env models.Env) (models.Env, error) {
 }
 
 // UpdateEnv to update environment information in database
-func (p *provider) UpdateEnv(env models.Env) (models.Env, error) {
+func (p *provider) UpdateEnv(ctx context.Context, env models.Env) (models.Env, error) {
 	env.UpdatedAt = time.Now().Unix()
-	collection, _ := p.db.Collection(nil, models.Collections.Env)
+	collection, _ := p.db.Collection(ctx, models.Collections.Env)
-	meta, err := collection.UpdateDocument(nil, env.Key, env)
+	meta, err := collection.UpdateDocument(ctx, env.Key, env)
 	if err != nil {
 		return env, err
 	}
@@ -43,11 +44,11 @@ func (p *provider) UpdateEnv(env models.Env) (models.Env, error) {
 }
 
 // GetEnv to get environment information from database
-func (p *provider) GetEnv() (models.Env, error) {
+func (p *provider) GetEnv(ctx context.Context) (models.Env, error) {
 	var env models.Env
 	query := fmt.Sprintf("FOR d in %s RETURN d", models.Collections.Env)
 
-	cursor, err := p.db.Query(nil, query, nil)
+	cursor, err := p.db.Query(ctx, query, nil)
 	if err != nil {
 		return env, err
 	}
@@ -60,7 +61,7 @@ func (p *provider) GetEnv() (models.Env, error) {
 			}
 			break
 		}
-		_, err := cursor.ReadDocument(nil, &env)
+		_, err := cursor.ReadDocument(ctx, &env)
 		if err != nil {
 			return env, err
 		}

server/db/providers/arangodb/provider.go

@@ -107,6 +107,47 @@ func NewProvider() (*provider, error) {
 		}
 	}
 
+	webhookCollectionExists, err := arangodb.CollectionExists(ctx, models.Collections.Webhook)
+	if !webhookCollectionExists {
+		_, err = arangodb.CreateCollection(ctx, models.Collections.Webhook, nil)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	webhookCollection, _ := arangodb.Collection(nil, models.Collections.Webhook)
+	webhookCollection.EnsureHashIndex(ctx, []string{"event_name"}, &arangoDriver.EnsureHashIndexOptions{
+		Unique: true,
+		Sparse: true,
+	})
+
+	webhookLogCollectionExists, err := arangodb.CollectionExists(ctx, models.Collections.WebhookLog)
+	if !webhookLogCollectionExists {
+		_, err = arangodb.CreateCollection(ctx, models.Collections.WebhookLog, nil)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	webhookLogCollection, _ := arangodb.Collection(nil, models.Collections.WebhookLog)
+	webhookLogCollection.EnsureHashIndex(ctx, []string{"webhook_id"}, &arangoDriver.EnsureHashIndexOptions{
+		Sparse: true,
+	})
+
+	emailTemplateCollectionExists, err := arangodb.CollectionExists(ctx, models.Collections.EmailTemplate)
+	if !emailTemplateCollectionExists {
+		_, err = arangodb.CreateCollection(ctx, models.Collections.EmailTemplate, nil)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	emailTemplateCollection, _ := arangodb.Collection(nil, models.Collections.EmailTemplate)
+	emailTemplateCollection.EnsureHashIndex(ctx, []string{"event_name"}, &arangoDriver.EnsureHashIndexOptions{
+		Unique: true,
+		Sparse: true,
+	})
+
 	return &provider{
 		db: arangodb,
 	}, err

server/db/providers/arangodb/session.go

@@ -1,7 +1,7 @@
 package arangodb
 
 import (
-	"fmt"
+	"context"
 	"time"
 
 	"github.com/authorizerdev/authorizer/server/db/models"
@@ -9,31 +9,17 @@ import (
 )
 
 // AddSession to save session information in database
-func (p *provider) AddSession(session models.Session) error {
+func (p *provider) AddSession(ctx context.Context, session models.Session) error {
 	if session.ID == "" {
 		session.ID = uuid.New().String()
 	}
 
 	session.CreatedAt = time.Now().Unix()
 	session.UpdatedAt = time.Now().Unix()
-	sessionCollection, _ := p.db.Collection(nil, models.Collections.Session)
+	sessionCollection, _ := p.db.Collection(ctx, models.Collections.Session)
-	_, err := sessionCollection.CreateDocument(nil, session)
+	_, err := sessionCollection.CreateDocument(ctx, session)
 	if err != nil {
 		return err
 	}
 	return nil
 }
-
-// DeleteSession to delete session information from database
-func (p *provider) DeleteSession(userId string) error {
-	query := fmt.Sprintf(`FOR d IN %s FILTER d.user_id == @userId REMOVE { _key: d._key } IN %s`, models.Collections.Session, models.Collections.Session)
-	bindVars := map[string]interface{}{
-		"userId": userId,
-	}
-	cursor, err := p.db.Query(nil, query, bindVars)
-	if err != nil {
-		return err
-	}
-	defer cursor.Close()
-	return nil
-}

server/db/providers/arangodb/user.go

@@ -15,7 +15,7 @@ import (
 )
 
 // AddUser to save user information in database
-func (p *provider) AddUser(user models.User) (models.User, error) {
+func (p *provider) AddUser(ctx context.Context, user models.User) (models.User, error) {
 	if user.ID == "" {
 		user.ID = uuid.New().String()
 	}
@@ -30,8 +30,8 @@ func (p *provider) AddUser(user models.User) (models.User, error) {
 
 	user.CreatedAt = time.Now().Unix()
 	user.UpdatedAt = time.Now().Unix()
-	userCollection, _ := p.db.Collection(nil, models.Collections.User)
+	userCollection, _ := p.db.Collection(ctx, models.Collections.User)
-	meta, err := userCollection.CreateDocument(arangoDriver.WithOverwrite(nil), user)
+	meta, err := userCollection.CreateDocument(arangoDriver.WithOverwrite(ctx), user)
 	if err != nil {
 		return user, err
 	}
@@ -42,10 +42,10 @@ func (p *provider) AddUser(user models.User) (models.User, error) {
 }
 
 // UpdateUser to update user information in database
-func (p *provider) UpdateUser(user models.User) (models.User, error) {
+func (p *provider) UpdateUser(ctx context.Context, user models.User) (models.User, error) {
 	user.UpdatedAt = time.Now().Unix()
-	collection, _ := p.db.Collection(nil, models.Collections.User)
+	collection, _ := p.db.Collection(ctx, models.Collections.User)
-	meta, err := collection.UpdateDocument(nil, user.Key, user)
+	meta, err := collection.UpdateDocument(ctx, user.Key, user)
 	if err != nil {
 		return user, err
 	}
@@ -56,24 +56,34 @@ func (p *provider) UpdateUser(user models.User) (models.User, error) {
 }
 
 // DeleteUser to delete user information from database
-func (p *provider) DeleteUser(user models.User) error {
+func (p *provider) DeleteUser(ctx context.Context, user models.User) error {
-	collection, _ := p.db.Collection(nil, models.Collections.User)
+	collection, _ := p.db.Collection(ctx, models.Collections.User)
-	_, err := collection.RemoveDocument(nil, user.Key)
+	_, err := collection.RemoveDocument(ctx, user.Key)
 	if err != nil {
 		return err
 	}
 
+	query := fmt.Sprintf(`FOR d IN %s FILTER d.user_id == @user_id REMOVE { _key: d._key } IN %s`, models.Collections.Session, models.Collections.Session)
+	bindVars := map[string]interface{}{
+		"user_id": user.ID,
+	}
+	cursor, err := p.db.Query(ctx, query, bindVars)
+	if err != nil {
+		return err
+	}
+	defer cursor.Close()
+
 	return nil
 }
 
 // ListUsers to get list of users from database
-func (p *provider) ListUsers(pagination model.Pagination) (*model.Users, error) {
+func (p *provider) ListUsers(ctx context.Context, pagination model.Pagination) (*model.Users, error) {
 	var users []*model.User
-	ctx := driver.WithQueryFullCount(context.Background())
+	sctx := driver.WithQueryFullCount(ctx)
 
 	query := fmt.Sprintf("FOR d in %s SORT d.created_at DESC LIMIT %d, %d RETURN d", models.Collections.User, pagination.Offset, pagination.Limit)
 
-	cursor, err := p.db.Query(ctx, query, nil)
+	cursor, err := p.db.Query(sctx, query, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -84,7 +94,7 @@ func (p *provider) ListUsers(pagination model.Pagination) (*model.Users, error)
 
 	for {
 		var user models.User
-		meta, err := cursor.ReadDocument(nil, &user)
+		meta, err := cursor.ReadDocument(ctx, &user)
 
 		if arangoDriver.IsNoMoreDocuments(err) {
 			break
@@ -104,7 +114,7 @@ func (p *provider) ListUsers(pagination model.Pagination) (*model.Users, error)
 }
 
 // GetUserByEmail to get user information from database using email address
-func (p *provider) GetUserByEmail(email string) (models.User, error) {
+func (p *provider) GetUserByEmail(ctx context.Context, email string) (models.User, error) {
 	var user models.User
 
 	query := fmt.Sprintf("FOR d in %s FILTER d.email == @email RETURN d", models.Collections.User)
@@ -112,7 +122,7 @@ func (p *provider) GetUserByEmail(email string) (models.User, error) {
 		"email": email,
 	}
 
-	cursor, err := p.db.Query(nil, query, bindVars)
+	cursor, err := p.db.Query(ctx, query, bindVars)
 	if err != nil {
 		return user, err
 	}
@@ -125,7 +135,7 @@ func (p *provider) GetUserByEmail(email string) (models.User, error) {
 			}
 			break
 		}
-		_, err := cursor.ReadDocument(nil, &user)
+		_, err := cursor.ReadDocument(ctx, &user)
 		if err != nil {
 			return user, err
 		}
@@ -135,7 +145,7 @@ func (p *provider) GetUserByEmail(email string) (models.User, error) {
 }
 
 // GetUserByID to get user information from database using user ID
-func (p *provider) GetUserByID(id string) (models.User, error) {
+func (p *provider) GetUserByID(ctx context.Context, id string) (models.User, error) {
 	var user models.User
 
 	query := fmt.Sprintf("FOR d in %s FILTER d._id == @id LIMIT 1 RETURN d", models.Collections.User)
@@ -143,7 +153,7 @@ func (p *provider) GetUserByID(id string) (models.User, error) {
 		"id": id,
 	}
 
-	cursor, err := p.db.Query(nil, query, bindVars)
+	cursor, err := p.db.Query(ctx, query, bindVars)
 	if err != nil {
 		return user, err
 	}
@@ -156,7 +166,7 @@ func (p *provider) GetUserByID(id string) (models.User, error) {
 			}
 			break
 		}
-		_, err := cursor.ReadDocument(nil, &user)
+		_, err := cursor.ReadDocument(ctx, &user)
 		if err != nil {
 			return user, err
 		}

server/db/providers/arangodb/verification_requests.go

@@ -12,15 +12,15 @@ import (
 )
 
 // AddVerification to save verification request in database
-func (p *provider) AddVerificationRequest(verificationRequest models.VerificationRequest) (models.VerificationRequest, error) {
+func (p *provider) AddVerificationRequest(ctx context.Context, verificationRequest models.VerificationRequest) (models.VerificationRequest, error) {
 	if verificationRequest.ID == "" {
 		verificationRequest.ID = uuid.New().String()
 	}
 
 	verificationRequest.CreatedAt = time.Now().Unix()
 	verificationRequest.UpdatedAt = time.Now().Unix()
-	verificationRequestRequestCollection, _ := p.db.Collection(nil, models.Collections.VerificationRequest)
+	verificationRequestRequestCollection, _ := p.db.Collection(ctx, models.Collections.VerificationRequest)
-	meta, err := verificationRequestRequestCollection.CreateDocument(nil, verificationRequest)
+	meta, err := verificationRequestRequestCollection.CreateDocument(ctx, verificationRequest)
 	if err != nil {
 		return verificationRequest, err
 	}
@@ -31,14 +31,14 @@ func (p *provider) AddVerificationRequest(verificationRequest models.Verificatio
 }
 
 // GetVerificationRequestByToken to get verification request from database using token
-func (p *provider) GetVerificationRequestByToken(token string) (models.VerificationRequest, error) {
+func (p *provider) GetVerificationRequestByToken(ctx context.Context, token string) (models.VerificationRequest, error) {
 	var verificationRequest models.VerificationRequest
 	query := fmt.Sprintf("FOR d in %s FILTER d.token == @token LIMIT 1 RETURN d", models.Collections.VerificationRequest)
 	bindVars := map[string]interface{}{
 		"token": token,
 	}
 
-	cursor, err := p.db.Query(nil, query, bindVars)
+	cursor, err := p.db.Query(ctx, query, bindVars)
 	if err != nil {
 		return verificationRequest, err
 	}
@@ -51,7 +51,7 @@ func (p *provider) GetVerificationRequestByToken(token string) (models.Verificat
 			}
 			break
 		}
-		_, err := cursor.ReadDocument(nil, &verificationRequest)
+		_, err := cursor.ReadDocument(ctx, &verificationRequest)
 		if err != nil {
 			return verificationRequest, err
 		}
@@ -61,7 +61,7 @@ func (p *provider) GetVerificationRequestByToken(token string) (models.Verificat
 }
 
 // GetVerificationRequestByEmail to get verification request by email from database
-func (p *provider) GetVerificationRequestByEmail(email string, identifier string) (models.VerificationRequest, error) {
+func (p *provider) GetVerificationRequestByEmail(ctx context.Context, email string, identifier string) (models.VerificationRequest, error) {
 	var verificationRequest models.VerificationRequest
 
 	query := fmt.Sprintf("FOR d in %s FILTER d.email == @email FILTER d.identifier == @identifier LIMIT 1 RETURN d", models.Collections.VerificationRequest)
@@ -70,7 +70,7 @@ func (p *provider) GetVerificationRequestByEmail(email string, identifier string
 		"identifier": identifier,
 	}
 
-	cursor, err := p.db.Query(nil, query, bindVars)
+	cursor, err := p.db.Query(ctx, query, bindVars)
 	if err != nil {
 		return verificationRequest, err
 	}
@@ -83,7 +83,7 @@ func (p *provider) GetVerificationRequestByEmail(email string, identifier string
 			}
 			break
 		}
-		_, err := cursor.ReadDocument(nil, &verificationRequest)
+		_, err := cursor.ReadDocument(ctx, &verificationRequest)
 		if err != nil {
 			return verificationRequest, err
 		}
@@ -93,12 +93,12 @@ func (p *provider) GetVerificationRequestByEmail(email string, identifier string
 }
 
 // ListVerificationRequests to get list of verification requests from database
-func (p *provider) ListVerificationRequests(pagination model.Pagination) (*model.VerificationRequests, error) {
+func (p *provider) ListVerificationRequests(ctx context.Context, pagination model.Pagination) (*model.VerificationRequests, error) {
 	var verificationRequests []*model.VerificationRequest
-	ctx := driver.WithQueryFullCount(context.Background())
+	sctx := driver.WithQueryFullCount(ctx)
 	query := fmt.Sprintf("FOR d in %s SORT d.created_at DESC LIMIT %d, %d RETURN d", models.Collections.VerificationRequest, pagination.Offset, pagination.Limit)
 
-	cursor, err := p.db.Query(ctx, query, nil)
+	cursor, err := p.db.Query(sctx, query, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -109,7 +109,7 @@ func (p *provider) ListVerificationRequests(pagination model.Pagination) (*model
 
 	for {
 		var verificationRequest models.VerificationRequest
-		meta, err := cursor.ReadDocument(nil, &verificationRequest)
+		meta, err := cursor.ReadDocument(ctx, &verificationRequest)
 
 		if driver.IsNoMoreDocuments(err) {
 			break
@@ -130,7 +130,7 @@ func (p *provider) ListVerificationRequests(pagination model.Pagination) (*model
 }
 
 // DeleteVerificationRequest to delete verification request from database
-func (p *provider) DeleteVerificationRequest(verificationRequest models.VerificationRequest) error {
+func (p *provider) DeleteVerificationRequest(ctx context.Context, verificationRequest models.VerificationRequest) error {
 	collection, _ := p.db.Collection(nil, models.Collections.VerificationRequest)
 	_, err := collection.RemoveDocument(nil, verificationRequest.Key)
 	if err != nil {

server/db/providers/arangodb/webhook.go

@@ -0,0 +1,161 @@
+package arangodb
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/arangodb/go-driver"
+	arangoDriver "github.com/arangodb/go-driver"
+	"github.com/authorizerdev/authorizer/server/db/models"
+	"github.com/authorizerdev/authorizer/server/graph/model"
+	"github.com/google/uuid"
+)
+
+// AddWebhook to add webhook
+func (p *provider) AddWebhook(ctx context.Context, webhook models.Webhook) (*model.Webhook, error) {
+	if webhook.ID == "" {
+		webhook.ID = uuid.New().String()
+	}
+
+	webhook.Key = webhook.ID
+	webhook.CreatedAt = time.Now().Unix()
+	webhook.UpdatedAt = time.Now().Unix()
+	webhookCollection, _ := p.db.Collection(ctx, models.Collections.Webhook)
+	_, err := webhookCollection.CreateDocument(ctx, webhook)
+	if err != nil {
+		return nil, err
+	}
+	return webhook.AsAPIWebhook(), nil
+}
+
+// UpdateWebhook to update webhook
+func (p *provider) UpdateWebhook(ctx context.Context, webhook models.Webhook) (*model.Webhook, error) {
+	webhook.UpdatedAt = time.Now().Unix()
+	webhookCollection, _ := p.db.Collection(ctx, models.Collections.Webhook)
+	meta, err := webhookCollection.UpdateDocument(ctx, webhook.Key, webhook)
+	if err != nil {
+		return nil, err
+	}
+
+	webhook.Key = meta.Key
+	webhook.ID = meta.ID.String()
+	return webhook.AsAPIWebhook(), nil
+}
+
+// ListWebhooks to list webhook
+func (p *provider) ListWebhook(ctx context.Context, pagination model.Pagination) (*model.Webhooks, error) {
+	webhooks := []*model.Webhook{}
+
+	query := fmt.Sprintf("FOR d in %s SORT d.created_at DESC LIMIT %d, %d RETURN d", models.Collections.Webhook, pagination.Offset, pagination.Limit)
+
+	sctx := driver.WithQueryFullCount(ctx)
+	cursor, err := p.db.Query(sctx, query, nil)
+	if err != nil {
+		return nil, err
+	}
+	defer cursor.Close()
+
+	paginationClone := pagination
+	paginationClone.Total = cursor.Statistics().FullCount()
+
+	for {
+		var webhook models.Webhook
+		meta, err := cursor.ReadDocument(ctx, &webhook)
+
+		if arangoDriver.IsNoMoreDocuments(err) {
+			break
+		} else if err != nil {
+			return nil, err
+		}
+
+		if meta.Key != "" {
+			webhooks = append(webhooks, webhook.AsAPIWebhook())
+		}
+	}
+
+	return &model.Webhooks{
+		Pagination: &paginationClone,
+		Webhooks:   webhooks,
+	}, nil
+}
+
+// GetWebhookByID to get webhook by id
+func (p *provider) GetWebhookByID(ctx context.Context, webhookID string) (*model.Webhook, error) {
+	var webhook models.Webhook
+	query := fmt.Sprintf("FOR d in %s FILTER d._key == @webhook_id RETURN d", models.Collections.Webhook)
+	bindVars := map[string]interface{}{
+		"webhook_id": webhookID,
+	}
+
+	cursor, err := p.db.Query(ctx, query, bindVars)
+	if err != nil {
+		return nil, err
+	}
+	defer cursor.Close()
+
+	for {
+		if !cursor.HasMore() {
+			if webhook.Key == "" {
+				return nil, fmt.Errorf("webhook not found")
+			}
+			break
+		}
+		_, err := cursor.ReadDocument(ctx, &webhook)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return webhook.AsAPIWebhook(), nil
+}
+
+// GetWebhookByEventName to get webhook by event_name
+func (p *provider) GetWebhookByEventName(ctx context.Context, eventName string) (*model.Webhook, error) {
+	var webhook models.Webhook
+	query := fmt.Sprintf("FOR d in %s FILTER d.event_name == @event_name RETURN d", models.Collections.Webhook)
+	bindVars := map[string]interface{}{
+		"event_name": eventName,
+	}
+
+	cursor, err := p.db.Query(ctx, query, bindVars)
+	if err != nil {
+		return nil, err
+	}
+	defer cursor.Close()
+
+	for {
+		if !cursor.HasMore() {
+			if webhook.Key == "" {
+				return nil, fmt.Errorf("webhook not found")
+			}
+			break
+		}
+		_, err := cursor.ReadDocument(ctx, &webhook)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return webhook.AsAPIWebhook(), nil
+}
+
+// DeleteWebhook to delete webhook
+func (p *provider) DeleteWebhook(ctx context.Context, webhook *model.Webhook) error {
+	webhookCollection, _ := p.db.Collection(ctx, models.Collections.Webhook)
+	_, err := webhookCollection.RemoveDocument(ctx, webhook.ID)
+	if err != nil {
+		return err
+	}
+
+	query := fmt.Sprintf("FOR d IN %s FILTER d.webhook_id == @webhook_id REMOVE { _key: d._key } IN %s", models.Collections.WebhookLog, models.Collections.WebhookLog)
+	bindVars := map[string]interface{}{
+		"webhook_id": webhook.ID,
+	}
+
+	cursor, err := p.db.Query(ctx, query, bindVars)
+	if err != nil {
+		return err
+	}
+	defer cursor.Close()
+
+	return nil
+}

server/db/providers/arangodb/webhook_log.go

@@ -0,0 +1,75 @@
+package arangodb
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/arangodb/go-driver"
+	arangoDriver "github.com/arangodb/go-driver"
+	"github.com/authorizerdev/authorizer/server/db/models"
+	"github.com/authorizerdev/authorizer/server/graph/model"
+	"github.com/google/uuid"
+)
+
+// AddWebhookLog to add webhook log
+func (p *provider) AddWebhookLog(ctx context.Context, webhookLog models.WebhookLog) (*model.WebhookLog, error) {
+	if webhookLog.ID == "" {
+		webhookLog.ID = uuid.New().String()
+	}
+
+	webhookLog.Key = webhookLog.ID
+	webhookLog.CreatedAt = time.Now().Unix()
+	webhookLog.UpdatedAt = time.Now().Unix()
+	webhookLogCollection, _ := p.db.Collection(ctx, models.Collections.WebhookLog)
+	_, err := webhookLogCollection.CreateDocument(ctx, webhookLog)
+	if err != nil {
+		return nil, err
+	}
+	return webhookLog.AsAPIWebhookLog(), nil
+}
+
+// ListWebhookLogs to list webhook logs
+func (p *provider) ListWebhookLogs(ctx context.Context, pagination model.Pagination, webhookID string) (*model.WebhookLogs, error) {
+	webhookLogs := []*model.WebhookLog{}
+	bindVariables := map[string]interface{}{}
+
+	query := fmt.Sprintf("FOR d in %s SORT d.created_at DESC LIMIT %d, %d RETURN d", models.Collections.WebhookLog, pagination.Offset, pagination.Limit)
+
+	if webhookID != "" {
+		query = fmt.Sprintf("FOR d in %s FILTER d.webhook_id == @webhook_id SORT d.created_at DESC LIMIT %d, %d RETURN d", models.Collections.WebhookLog, pagination.Offset, pagination.Limit)
+		bindVariables = map[string]interface{}{
+			"webhook_id": webhookID,
+		}
+	}
+
+	sctx := driver.WithQueryFullCount(ctx)
+	cursor, err := p.db.Query(sctx, query, bindVariables)
+	if err != nil {
+		return nil, err
+	}
+	defer cursor.Close()
+
+	paginationClone := pagination
+	paginationClone.Total = cursor.Statistics().FullCount()
+
+	for {
+		var webhookLog models.WebhookLog
+		meta, err := cursor.ReadDocument(ctx, &webhookLog)
+
+		if arangoDriver.IsNoMoreDocuments(err) {
+			break
+		} else if err != nil {
+			return nil, err
+		}
+
+		if meta.Key != "" {
+			webhookLogs = append(webhookLogs, webhookLog.AsAPIWebhookLog())
+		}
+	}
+
+	return &model.WebhookLogs{
+		Pagination:  &paginationClone,
+		WebhookLogs: webhookLogs,
+	}, nil
+}

server/db/providers/cassandradb/email_template.go

@@ -0,0 +1,159 @@
+package cassandradb
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"strings"
+	"time"
+
+	"github.com/authorizerdev/authorizer/server/db/models"
+	"github.com/authorizerdev/authorizer/server/graph/model"
+	"github.com/gocql/gocql"
+	"github.com/google/uuid"
+)
+
+// AddEmailTemplate to add EmailTemplate
+func (p *provider) AddEmailTemplate(ctx context.Context, emailTemplate models.EmailTemplate) (*model.EmailTemplate, error) {
+	if emailTemplate.ID == "" {
+		emailTemplate.ID = uuid.New().String()
+	}
+
+	emailTemplate.Key = emailTemplate.ID
+	emailTemplate.CreatedAt = time.Now().Unix()
+	emailTemplate.UpdatedAt = time.Now().Unix()
+
+	existingEmailTemplate, _ := p.GetEmailTemplateByEventName(ctx, emailTemplate.EventName)
+	if existingEmailTemplate != nil {
+		return nil, fmt.Errorf("Email template with %s event_name already exists", emailTemplate.EventName)
+	}
+
+	insertQuery := fmt.Sprintf("INSERT INTO %s (id, event_name, template,  created_at, updated_at) VALUES ('%s', '%s', '%s', %d, %d)", KeySpace+"."+models.Collections.EmailTemplate, emailTemplate.ID, emailTemplate.EventName, emailTemplate.Template, emailTemplate.CreatedAt, emailTemplate.UpdatedAt)
+	err := p.db.Query(insertQuery).Exec()
+	if err != nil {
+		return nil, err
+	}
+
+	return emailTemplate.AsAPIEmailTemplate(), nil
+}
+
+// UpdateEmailTemplate to update EmailTemplate
+func (p *provider) UpdateEmailTemplate(ctx context.Context, emailTemplate models.EmailTemplate) (*model.EmailTemplate, error) {
+	emailTemplate.UpdatedAt = time.Now().Unix()
+
+	bytes, err := json.Marshal(emailTemplate)
+	if err != nil {
+		return nil, err
+	}
+	// use decoder instead of json.Unmarshall, because it converts int64 -> float64 after unmarshalling
+	decoder := json.NewDecoder(strings.NewReader(string(bytes)))
+	decoder.UseNumber()
+	emailTemplateMap := map[string]interface{}{}
+	err = decoder.Decode(&emailTemplateMap)
+	if err != nil {
+		return nil, err
+	}
+
+	updateFields := ""
+	for key, value := range emailTemplateMap {
+		if key == "_id" {
+			continue
+		}
+
+		if key == "_key" {
+			continue
+		}
+
+		if value == nil {
+			updateFields += fmt.Sprintf("%s = null,", key)
+			continue
+		}
+
+		valueType := reflect.TypeOf(value)
+		if valueType.Name() == "string" {
+			updateFields += fmt.Sprintf("%s = '%s', ", key, value.(string))
+		} else {
+			updateFields += fmt.Sprintf("%s = %v, ", key, value)
+		}
+	}
+	updateFields = strings.Trim(updateFields, " ")
+	updateFields = strings.TrimSuffix(updateFields, ",")
+
+	query := fmt.Sprintf("UPDATE %s SET %s WHERE id = '%s'", KeySpace+"."+models.Collections.EmailTemplate, updateFields, emailTemplate.ID)
+	err = p.db.Query(query).Exec()
+	if err != nil {
+		return nil, err
+	}
+
+	return emailTemplate.AsAPIEmailTemplate(), nil
+}
+
+// ListEmailTemplates to list EmailTemplate
+func (p *provider) ListEmailTemplate(ctx context.Context, pagination model.Pagination) (*model.EmailTemplates, error) {
+	emailTemplates := []*model.EmailTemplate{}
+	paginationClone := pagination
+
+	totalCountQuery := fmt.Sprintf(`SELECT COUNT(*) FROM %s`, KeySpace+"."+models.Collections.EmailTemplate)
+	err := p.db.Query(totalCountQuery).Consistency(gocql.One).Scan(&paginationClone.Total)
+	if err != nil {
+		return nil, err
+	}
+
+	// there is no offset in cassandra
+	// so we fetch till limit + offset
+	// and return the results from offset to limit
+	query := fmt.Sprintf("SELECT id, event_name, template, created_at, updated_at FROM %s LIMIT %d", KeySpace+"."+models.Collections.EmailTemplate, pagination.Limit+pagination.Offset)
+
+	scanner := p.db.Query(query).Iter().Scanner()
+	counter := int64(0)
+	for scanner.Next() {
+		if counter >= pagination.Offset {
+			var emailTemplate models.EmailTemplate
+			err := scanner.Scan(&emailTemplate.ID, &emailTemplate.EventName, &emailTemplate.Template, &emailTemplate.CreatedAt, &emailTemplate.UpdatedAt)
+			if err != nil {
+				return nil, err
+			}
+			emailTemplates = append(emailTemplates, emailTemplate.AsAPIEmailTemplate())
+		}
+		counter++
+	}
+
+	return &model.EmailTemplates{
+		Pagination:     &paginationClone,
+		EmailTemplates: emailTemplates,
+	}, nil
+}
+
+// GetEmailTemplateByID to get EmailTemplate by id
+func (p *provider) GetEmailTemplateByID(ctx context.Context, emailTemplateID string) (*model.EmailTemplate, error) {
+	var emailTemplate models.EmailTemplate
+	query := fmt.Sprintf(`SELECT id, event_name, template, created_at, updated_at FROM %s WHERE id = '%s' LIMIT 1`, KeySpace+"."+models.Collections.EmailTemplate, emailTemplateID)
+	err := p.db.Query(query).Consistency(gocql.One).Scan(&emailTemplate.ID, &emailTemplate.EventName, &emailTemplate.Template, &emailTemplate.CreatedAt, &emailTemplate.UpdatedAt)
+	if err != nil {
+		return nil, err
+	}
+	return emailTemplate.AsAPIEmailTemplate(), nil
+}
+
+// GetEmailTemplateByEventName to get EmailTemplate by event_name
+func (p *provider) GetEmailTemplateByEventName(ctx context.Context, eventName string) (*model.EmailTemplate, error) {
+	var emailTemplate models.EmailTemplate
+	query := fmt.Sprintf(`SELECT id, event_name, template, created_at, updated_at FROM %s WHERE event_name = '%s' LIMIT 1 ALLOW FILTERING`, KeySpace+"."+models.Collections.EmailTemplate, eventName)
+	err := p.db.Query(query).Consistency(gocql.One).Scan(&emailTemplate.ID, &emailTemplate.EventName, &emailTemplate.Template, &emailTemplate.CreatedAt, &emailTemplate.UpdatedAt)
+	if err != nil {
+		return nil, err
+	}
+	return emailTemplate.AsAPIEmailTemplate(), nil
+}
+
+// DeleteEmailTemplate to delete EmailTemplate
+func (p *provider) DeleteEmailTemplate(ctx context.Context, emailTemplate *model.EmailTemplate) error {
+	query := fmt.Sprintf("DELETE FROM %s WHERE id = '%s'", KeySpace+"."+models.Collections.EmailTemplate, emailTemplate.ID)
+	err := p.db.Query(query).Exec()
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

server/db/providers/cassandradb/env.go

@@ -1,6 +1,7 @@
 package cassandradb
 
 import (
+	"context"
 	"fmt"
 	"time"
 
@@ -10,7 +11,7 @@ import (
 )
 
 // AddEnv to save environment information in database
-func (p *provider) AddEnv(env models.Env) (models.Env, error) {
+func (p *provider) AddEnv(ctx context.Context, env models.Env) (models.Env, error) {
 	if env.ID == "" {
 		env.ID = uuid.New().String()
 	}
@@ -27,7 +28,7 @@ func (p *provider) AddEnv(env models.Env) (models.Env, error) {
 }
 
 // UpdateEnv to update environment information in database
-func (p *provider) UpdateEnv(env models.Env) (models.Env, error) {
+func (p *provider) UpdateEnv(ctx context.Context, env models.Env) (models.Env, error) {
 	env.UpdatedAt = time.Now().Unix()
 
 	updateEnvQuery := fmt.Sprintf("UPDATE %s SET env = '%s', updated_at = %d WHERE id = '%s'", KeySpace+"."+models.Collections.Env, env.EnvData, env.UpdatedAt, env.ID)
@@ -39,7 +40,7 @@ func (p *provider) UpdateEnv(env models.Env) (models.Env, error) {
 }
 
 // GetEnv to get environment information from database
-func (p *provider) GetEnv() (models.Env, error) {
+func (p *provider) GetEnv(ctx context.Context) (models.Env, error) {
 	var env models.Env
 
 	query := fmt.Sprintf("SELECT id, env, hash, created_at, updated_at FROM %s LIMIT 1", KeySpace+"."+models.Collections.Env)

server/db/providers/cassandradb/provider.go

@@ -5,6 +5,7 @@ import (
 	"crypto/x509"
 	"fmt"
 	"strings"
+	"time"
 
 	"github.com/authorizerdev/authorizer/server/constants"
 	"github.com/authorizerdev/authorizer/server/crypto"
@@ -96,6 +97,8 @@ func NewProvider() (*provider, error) {
 		NumRetries: 3,
 	}
 	cassandraClient.Consistency = gocql.LocalQuorum
+	cassandraClient.ConnectTimeout = 10 * time.Second
+	cassandraClient.ProtoVersion = 4
 
 	session, err := cassandraClient.CreateSession()
 	if err != nil {
@@ -140,6 +143,11 @@ func NewProvider() (*provider, error) {
 	if err != nil {
 		return nil, err
 	}
+	sessionIndexQuery := fmt.Sprintf("CREATE INDEX IF NOT EXISTS authorizer_session_user_id ON %s.%s (user_id)", KeySpace, models.Collections.Session)
+	err = session.Query(sessionIndexQuery).Exec()
+	if err != nil {
+		return nil, err
+	}
 
 	userCollectionQuery := fmt.Sprintf("CREATE TABLE IF NOT EXISTS %s.%s (id text, email text, email_verified_at bigint, password text, signup_methods text, given_name text, family_name text, middle_name text, nickname text, gender text, birthdate text, phone_number text, phone_number_verified_at bigint, picture text, roles text, updated_at bigint, created_at bigint, revoked_timestamp bigint, PRIMARY KEY (id))", KeySpace, models.Collections.User)
 	err = session.Query(userCollectionQuery).Exec()
@@ -174,6 +182,39 @@ func NewProvider() (*provider, error) {
 		return nil, err
 	}
 
+	webhookCollectionQuery := fmt.Sprintf("CREATE TABLE IF NOT EXISTS %s.%s (id text, event_name text, endpoint text, enabled boolean, headers text, updated_at bigint, created_at bigint, PRIMARY KEY (id))", KeySpace, models.Collections.Webhook)
+	err = session.Query(webhookCollectionQuery).Exec()
+	if err != nil {
+		return nil, err
+	}
+	webhookIndexQuery := fmt.Sprintf("CREATE INDEX IF NOT EXISTS authorizer_webhook_event_name ON %s.%s (event_name)", KeySpace, models.Collections.Webhook)
+	err = session.Query(webhookIndexQuery).Exec()
+	if err != nil {
+		return nil, err
+	}
+
+	webhookLogCollectionQuery := fmt.Sprintf("CREATE TABLE IF NOT EXISTS %s.%s (id text, http_status bigint, response text, request text, webhook_id text,updated_at bigint, created_at bigint, PRIMARY KEY (id))", KeySpace, models.Collections.WebhookLog)
+	err = session.Query(webhookLogCollectionQuery).Exec()
+	if err != nil {
+		return nil, err
+	}
+	webhookLogIndexQuery := fmt.Sprintf("CREATE INDEX IF NOT EXISTS authorizer_webhook_log_webhook_id ON %s.%s (webhook_id)", KeySpace, models.Collections.WebhookLog)
+	err = session.Query(webhookLogIndexQuery).Exec()
+	if err != nil {
+		return nil, err
+	}
+
+	emailTemplateCollectionQuery := fmt.Sprintf("CREATE TABLE IF NOT EXISTS %s.%s (id text, event_name text, template text, updated_at bigint, created_at bigint, PRIMARY KEY (id))", KeySpace, models.Collections.EmailTemplate)
+	err = session.Query(emailTemplateCollectionQuery).Exec()
+	if err != nil {
+		return nil, err
+	}
+	emailTemplateIndexQuery := fmt.Sprintf("CREATE INDEX IF NOT EXISTS authorizer_email_template_event_name ON %s.%s (event_name)", KeySpace, models.Collections.EmailTemplate)
+	err = session.Query(emailTemplateIndexQuery).Exec()
+	if err != nil {
+		return nil, err
+	}
+
 	return &provider{
 		db: session,
 	}, err

server/db/providers/cassandradb/session.go

@@ -1,6 +1,7 @@
 package cassandradb
 
 import (
+	"context"
 	"fmt"
 	"time"
 
@@ -9,7 +10,7 @@ import (
 )
 
 // AddSession to save session information in database
-func (p *provider) AddSession(session models.Session) error {
+func (p *provider) AddSession(ctx context.Context, session models.Session) error {
 	if session.ID == "" {
 		session.ID = uuid.New().String()
 	}
@@ -24,13 +25,3 @@ func (p *provider) AddSession(session models.Session) error {
 	}
 	return nil
 }
-
-// DeleteSession to delete session information from database
-func (p *provider) DeleteSession(userId string) error {
-	deleteSessionQuery := fmt.Sprintf("DELETE FROM %s WHERE user_id = '%s'", KeySpace+"."+models.Collections.Session, userId)
-	err := p.db.Query(deleteSessionQuery).Exec()
-	if err != nil {
-		return err
-	}
-	return nil
-}

server/db/providers/cassandradb/user.go

@@ -1,6 +1,7 @@
 package cassandradb
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"reflect"
@@ -16,7 +17,7 @@ import (
 )
 
 // AddUser to save user information in database
-func (p *provider) AddUser(user models.User) (models.User, error) {
+func (p *provider) AddUser(ctx context.Context, user models.User) (models.User, error) {
 	if user.ID == "" {
 		user.ID = uuid.New().String()
 	}
@@ -79,7 +80,7 @@ func (p *provider) AddUser(user models.User) (models.User, error) {
 }
 
 // UpdateUser to update user information in database
-func (p *provider) UpdateUser(user models.User) (models.User, error) {
+func (p *provider) UpdateUser(ctx context.Context, user models.User) (models.User, error) {
 	user.UpdatedAt = time.Now().Unix()
 
 	bytes, err := json.Marshal(user)
@@ -97,10 +98,11 @@ func (p *provider) UpdateUser(user models.User) (models.User, error) {
 
 	updateFields := ""
 	for key, value := range userMap {
-		if value != nil && key != "_id" {
+		if key == "_id" {
+			continue
 		}
 
-		if key == "_id" {
+		if key == "_key" {
 			continue
 		}
 
@@ -130,14 +132,36 @@ func (p *provider) UpdateUser(user models.User) (models.User, error) {
 }
 
 // DeleteUser to delete user information from database
-func (p *provider) DeleteUser(user models.User) error {
+func (p *provider) DeleteUser(ctx context.Context, user models.User) error {
 	query := fmt.Sprintf("DELETE FROM %s WHERE id = '%s'", KeySpace+"."+models.Collections.User, user.ID)
 	err := p.db.Query(query).Exec()
-	return err
+	if err != nil {
+		return err
+	}
+
+	getSessionsQuery := fmt.Sprintf("SELECT id FROM %s WHERE user_id = '%s' ALLOW FILTERING", KeySpace+"."+models.Collections.Session, user.ID)
+	scanner := p.db.Query(getSessionsQuery).Iter().Scanner()
+	sessionIDs := ""
+	for scanner.Next() {
+		var wlID string
+		err = scanner.Scan(&wlID)
+		if err != nil {
+			return err
+		}
+		sessionIDs += fmt.Sprintf("'%s',", wlID)
+	}
+	sessionIDs = strings.TrimSuffix(sessionIDs, ",")
+	deleteSessionQuery := fmt.Sprintf("DELETE FROM %s WHERE id IN (%s)", KeySpace+"."+models.Collections.Session, sessionIDs)
+	err = p.db.Query(deleteSessionQuery).Exec()
+	if err != nil {
+		return err
+	}
+
+	return nil
 }
 
 // ListUsers to get list of users from database
-func (p *provider) ListUsers(pagination model.Pagination) (*model.Users, error) {
+func (p *provider) ListUsers(ctx context.Context, pagination model.Pagination) (*model.Users, error) {
 	responseUsers := []*model.User{}
 	paginationClone := pagination
 	totalCountQuery := fmt.Sprintf(`SELECT COUNT(*) FROM %s`, KeySpace+"."+models.Collections.User)
@@ -171,9 +195,9 @@ func (p *provider) ListUsers(pagination model.Pagination) (*model.Users, error)
 }
 
 // GetUserByEmail to get user information from database using email address
-func (p *provider) GetUserByEmail(email string) (models.User, error) {
+func (p *provider) GetUserByEmail(ctx context.Context, email string) (models.User, error) {
 	var user models.User
-	query := fmt.Sprintf("SELECT id, email, email_verified_at, password, signup_methods, given_name, family_name, middle_name, nickname, birthdate, phone_number, phone_number_verified_at, picture, roles, revoked_timestamp, created_at, updated_at FROM %s WHERE email = '%s' LIMIT 1", KeySpace+"."+models.Collections.User, email)
+	query := fmt.Sprintf("SELECT id, email, email_verified_at, password, signup_methods, given_name, family_name, middle_name, nickname, birthdate, phone_number, phone_number_verified_at, picture, roles, revoked_timestamp, created_at, updated_at FROM %s WHERE email = '%s' LIMIT 1 ALLOW FILTERING", KeySpace+"."+models.Collections.User, email)
 	err := p.db.Query(query).Consistency(gocql.One).Scan(&user.ID, &user.Email, &user.EmailVerifiedAt, &user.Password, &user.SignupMethods, &user.GivenName, &user.FamilyName, &user.MiddleName, &user.Nickname, &user.Birthdate, &user.PhoneNumber, &user.PhoneNumberVerifiedAt, &user.Picture, &user.Roles, &user.RevokedTimestamp, &user.CreatedAt, &user.UpdatedAt)
 	if err != nil {
 		return user, err
@@ -182,7 +206,7 @@ func (p *provider) GetUserByEmail(email string) (models.User, error) {
 }
 
 // GetUserByID to get user information from database using user ID
-func (p *provider) GetUserByID(id string) (models.User, error) {
+func (p *provider) GetUserByID(ctx context.Context, id string) (models.User, error) {
 	var user models.User
 	query := fmt.Sprintf("SELECT id, email, email_verified_at, password, signup_methods, given_name, family_name, middle_name, nickname, birthdate, phone_number, phone_number_verified_at, picture, roles, revoked_timestamp, created_at, updated_at FROM %s WHERE id = '%s' LIMIT 1", KeySpace+"."+models.Collections.User, id)
 	err := p.db.Query(query).Consistency(gocql.One).Scan(&user.ID, &user.Email, &user.EmailVerifiedAt, &user.Password, &user.SignupMethods, &user.GivenName, &user.FamilyName, &user.MiddleName, &user.Nickname, &user.Birthdate, &user.PhoneNumber, &user.PhoneNumberVerifiedAt, &user.Picture, &user.Roles, &user.RevokedTimestamp, &user.CreatedAt, &user.UpdatedAt)

server/db/providers/cassandradb/verification_requests.go

@@ -1,6 +1,7 @@
 package cassandradb
 
 import (
+	"context"
 	"fmt"
 	"time"
 
@@ -11,7 +12,7 @@ import (
 )
 
 // AddVerification to save verification request in database
-func (p *provider) AddVerificationRequest(verificationRequest models.VerificationRequest) (models.VerificationRequest, error) {
+func (p *provider) AddVerificationRequest(ctx context.Context, verificationRequest models.VerificationRequest) (models.VerificationRequest, error) {
 	if verificationRequest.ID == "" {
 		verificationRequest.ID = uuid.New().String()
 	}
@@ -28,7 +29,7 @@ func (p *provider) AddVerificationRequest(verificationRequest models.Verificatio
 }
 
 // GetVerificationRequestByToken to get verification request from database using token
-func (p *provider) GetVerificationRequestByToken(token string) (models.VerificationRequest, error) {
+func (p *provider) GetVerificationRequestByToken(ctx context.Context, token string) (models.VerificationRequest, error) {
 	var verificationRequest models.VerificationRequest
 	query := fmt.Sprintf(`SELECT id, jwt_token, identifier, expires_at, email, nonce, redirect_uri, created_at, updated_at FROM %s WHERE jwt_token = '%s' LIMIT 1`, KeySpace+"."+models.Collections.VerificationRequest, token)
 
@@ -40,7 +41,7 @@ func (p *provider) GetVerificationRequestByToken(token string) (models.Verificat
 }
 
 // GetVerificationRequestByEmail to get verification request by email from database
-func (p *provider) GetVerificationRequestByEmail(email string, identifier string) (models.VerificationRequest, error) {
+func (p *provider) GetVerificationRequestByEmail(ctx context.Context, email string, identifier string) (models.VerificationRequest, error) {
 	var verificationRequest models.VerificationRequest
 	query := fmt.Sprintf(`SELECT id, jwt_token, identifier, expires_at, email, nonce, redirect_uri, created_at, updated_at FROM %s WHERE email = '%s' AND identifier = '%s' LIMIT 1 ALLOW FILTERING`, KeySpace+"."+models.Collections.VerificationRequest, email, identifier)
 
@@ -53,7 +54,7 @@ func (p *provider) GetVerificationRequestByEmail(email string, identifier string
 }
 
 // ListVerificationRequests to get list of verification requests from database
-func (p *provider) ListVerificationRequests(pagination model.Pagination) (*model.VerificationRequests, error) {
+func (p *provider) ListVerificationRequests(ctx context.Context, pagination model.Pagination) (*model.VerificationRequests, error) {
 	var verificationRequests []*model.VerificationRequest
 
 	paginationClone := pagination
@@ -89,7 +90,7 @@ func (p *provider) ListVerificationRequests(pagination model.Pagination) (*model
 }
 
 // DeleteVerificationRequest to delete verification request from database
-func (p *provider) DeleteVerificationRequest(verificationRequest models.VerificationRequest) error {
+func (p *provider) DeleteVerificationRequest(ctx context.Context, verificationRequest models.VerificationRequest) error {
 	query := fmt.Sprintf("DELETE FROM %s WHERE id = '%s'", KeySpace+"."+models.Collections.VerificationRequest, verificationRequest.ID)
 	err := p.db.Query(query).Exec()
 	if err != nil {

server/db/providers/cassandradb/webhook.go

@@ -0,0 +1,172 @@
+package cassandradb
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"strings"
+	"time"
+
+	"github.com/authorizerdev/authorizer/server/db/models"
+	"github.com/authorizerdev/authorizer/server/graph/model"
+	"github.com/gocql/gocql"
+	"github.com/google/uuid"
+)
+
+// AddWebhook to add webhook
+func (p *provider) AddWebhook(ctx context.Context, webhook models.Webhook) (*model.Webhook, error) {
+	if webhook.ID == "" {
+		webhook.ID = uuid.New().String()
+	}
+
+	webhook.Key = webhook.ID
+	webhook.CreatedAt = time.Now().Unix()
+	webhook.UpdatedAt = time.Now().Unix()
+
+	existingHook, _ := p.GetWebhookByEventName(ctx, webhook.EventName)
+	if existingHook != nil {
+		return nil, fmt.Errorf("Webhook with %s event_name already exists", webhook.EventName)
+	}
+
+	insertQuery := fmt.Sprintf("INSERT INTO %s (id, event_name, endpoint, headers, enabled,  created_at, updated_at) VALUES ('%s', '%s', '%s', '%s', %t, %d, %d)", KeySpace+"."+models.Collections.Webhook, webhook.ID, webhook.EventName, webhook.EndPoint, webhook.Headers, webhook.Enabled, webhook.CreatedAt, webhook.UpdatedAt)
+	err := p.db.Query(insertQuery).Exec()
+	if err != nil {
+		return nil, err
+	}
+
+	return webhook.AsAPIWebhook(), nil
+}
+
+// UpdateWebhook to update webhook
+func (p *provider) UpdateWebhook(ctx context.Context, webhook models.Webhook) (*model.Webhook, error) {
+	webhook.UpdatedAt = time.Now().Unix()
+
+	bytes, err := json.Marshal(webhook)
+	if err != nil {
+		return nil, err
+	}
+	// use decoder instead of json.Unmarshall, because it converts int64 -> float64 after unmarshalling
+	decoder := json.NewDecoder(strings.NewReader(string(bytes)))
+	decoder.UseNumber()
+	webhookMap := map[string]interface{}{}
+	err = decoder.Decode(&webhookMap)
+	if err != nil {
+		return nil, err
+	}
+
+	updateFields := ""
+	for key, value := range webhookMap {
+		if key == "_id" {
+			continue
+		}
+
+		if key == "_key" {
+			continue
+		}
+
+		if value == nil {
+			updateFields += fmt.Sprintf("%s = null,", key)
+			continue
+		}
+
+		valueType := reflect.TypeOf(value)
+		if valueType.Name() == "string" {
+			updateFields += fmt.Sprintf("%s = '%s', ", key, value.(string))
+		} else {
+			updateFields += fmt.Sprintf("%s = %v, ", key, value)
+		}
+	}
+	updateFields = strings.Trim(updateFields, " ")
+	updateFields = strings.TrimSuffix(updateFields, ",")
+
+	query := fmt.Sprintf("UPDATE %s SET %s WHERE id = '%s'", KeySpace+"."+models.Collections.Webhook, updateFields, webhook.ID)
+	err = p.db.Query(query).Exec()
+	if err != nil {
+		return nil, err
+	}
+	return webhook.AsAPIWebhook(), nil
+}
+
+// ListWebhooks to list webhook
+func (p *provider) ListWebhook(ctx context.Context, pagination model.Pagination) (*model.Webhooks, error) {
+	webhooks := []*model.Webhook{}
+	paginationClone := pagination
+
+	totalCountQuery := fmt.Sprintf(`SELECT COUNT(*) FROM %s`, KeySpace+"."+models.Collections.Webhook)
+	err := p.db.Query(totalCountQuery).Consistency(gocql.One).Scan(&paginationClone.Total)
+	if err != nil {
+		return nil, err
+	}
+
+	// there is no offset in cassandra
+	// so we fetch till limit + offset
+	// and return the results from offset to limit
+	query := fmt.Sprintf("SELECT id, event_name, endpoint, headers, enabled, created_at, updated_at FROM %s LIMIT %d", KeySpace+"."+models.Collections.Webhook, pagination.Limit+pagination.Offset)
+
+	scanner := p.db.Query(query).Iter().Scanner()
+	counter := int64(0)
+	for scanner.Next() {
+		if counter >= pagination.Offset {
+			var webhook models.Webhook
+			err := scanner.Scan(&webhook.ID, &webhook.EventName, &webhook.EndPoint, &webhook.Headers, &webhook.Enabled, &webhook.CreatedAt, &webhook.UpdatedAt)
+			if err != nil {
+				return nil, err
+			}
+			webhooks = append(webhooks, webhook.AsAPIWebhook())
+		}
+		counter++
+	}
+
+	return &model.Webhooks{
+		Pagination: &paginationClone,
+		Webhooks:   webhooks,
+	}, nil
+}
+
+// GetWebhookByID to get webhook by id
+func (p *provider) GetWebhookByID(ctx context.Context, webhookID string) (*model.Webhook, error) {
+	var webhook models.Webhook
+	query := fmt.Sprintf(`SELECT id, event_name, endpoint, headers, enabled, created_at, updated_at FROM %s WHERE id = '%s' LIMIT 1`, KeySpace+"."+models.Collections.Webhook, webhookID)
+	err := p.db.Query(query).Consistency(gocql.One).Scan(&webhook.ID, &webhook.EventName, &webhook.EndPoint, &webhook.Headers, &webhook.Enabled, &webhook.CreatedAt, &webhook.UpdatedAt)
+	if err != nil {
+		return nil, err
+	}
+	return webhook.AsAPIWebhook(), nil
+}
+
+// GetWebhookByEventName to get webhook by event_name
+func (p *provider) GetWebhookByEventName(ctx context.Context, eventName string) (*model.Webhook, error) {
+	var webhook models.Webhook
+	query := fmt.Sprintf(`SELECT id, event_name, endpoint, headers, enabled, created_at, updated_at FROM %s WHERE event_name = '%s' LIMIT 1 ALLOW FILTERING`, KeySpace+"."+models.Collections.Webhook, eventName)
+	err := p.db.Query(query).Consistency(gocql.One).Scan(&webhook.ID, &webhook.EventName, &webhook.EndPoint, &webhook.Headers, &webhook.Enabled, &webhook.CreatedAt, &webhook.UpdatedAt)
+	if err != nil {
+		return nil, err
+	}
+	return webhook.AsAPIWebhook(), nil
+}
+
+// DeleteWebhook to delete webhook
+func (p *provider) DeleteWebhook(ctx context.Context, webhook *model.Webhook) error {
+	query := fmt.Sprintf("DELETE FROM %s WHERE id = '%s'", KeySpace+"."+models.Collections.Webhook, webhook.ID)
+	err := p.db.Query(query).Exec()
+	if err != nil {
+		return err
+	}
+
+	getWebhookLogQuery := fmt.Sprintf("SELECT id FROM %s WHERE webhook_id = '%s' ALLOW FILTERING", KeySpace+"."+models.Collections.WebhookLog, webhook.ID)
+	scanner := p.db.Query(getWebhookLogQuery).Iter().Scanner()
+	webhookLogIDs := ""
+	for scanner.Next() {
+		var wlID string
+		err = scanner.Scan(&wlID)
+		if err != nil {
+			return err
+		}
+		webhookLogIDs += fmt.Sprintf("'%s',", wlID)
+	}
+	webhookLogIDs = strings.TrimSuffix(webhookLogIDs, ",")
+	query = fmt.Sprintf("DELETE FROM %s WHERE id IN (%s)", KeySpace+"."+models.Collections.WebhookLog, webhookLogIDs)
+	err = p.db.Query(query).Exec()
+	return err
+}

server/db/providers/cassandradb/webhook_log.go

@@ -0,0 +1,70 @@
+package cassandradb
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/authorizerdev/authorizer/server/db/models"
+	"github.com/authorizerdev/authorizer/server/graph/model"
+	"github.com/gocql/gocql"
+	"github.com/google/uuid"
+)
+
+// AddWebhookLog to add webhook log
+func (p *provider) AddWebhookLog(ctx context.Context, webhookLog models.WebhookLog) (*model.WebhookLog, error) {
+	if webhookLog.ID == "" {
+		webhookLog.ID = uuid.New().String()
+	}
+
+	webhookLog.Key = webhookLog.ID
+	webhookLog.CreatedAt = time.Now().Unix()
+	webhookLog.UpdatedAt = time.Now().Unix()
+
+	insertQuery := fmt.Sprintf("INSERT INTO %s (id, http_status, response, request, webhook_id, created_at, updated_at) VALUES ('%s', %d,'%s', '%s', '%s', %d, %d)", KeySpace+"."+models.Collections.WebhookLog, webhookLog.ID, webhookLog.HttpStatus, webhookLog.Response, webhookLog.Request, webhookLog.WebhookID, webhookLog.CreatedAt, webhookLog.UpdatedAt)
+	err := p.db.Query(insertQuery).Exec()
+	if err != nil {
+		return nil, err
+	}
+	return webhookLog.AsAPIWebhookLog(), nil
+}
+
+// ListWebhookLogs to list webhook logs
+func (p *provider) ListWebhookLogs(ctx context.Context, pagination model.Pagination, webhookID string) (*model.WebhookLogs, error) {
+	webhookLogs := []*model.WebhookLog{}
+	paginationClone := pagination
+	totalCountQuery := fmt.Sprintf(`SELECT COUNT(*) FROM %s`, KeySpace+"."+models.Collections.WebhookLog)
+	// there is no offset in cassandra
+	// so we fetch till limit + offset
+	// and return the results from offset to limit
+	query := fmt.Sprintf("SELECT id, http_status, response, request, webhook_id, created_at, updated_at FROM %s LIMIT %d", KeySpace+"."+models.Collections.WebhookLog, pagination.Limit+pagination.Offset)
+
+	if webhookID != "" {
+		totalCountQuery = fmt.Sprintf(`SELECT COUNT(*) FROM %s WHERE webhook_id='%s' ALLOW FILTERING`, KeySpace+"."+models.Collections.WebhookLog, webhookID)
+		query = fmt.Sprintf("SELECT id, http_status, response, request, webhook_id, created_at, updated_at FROM %s WHERE webhook_id = '%s' LIMIT %d ALLOW FILTERING", KeySpace+"."+models.Collections.WebhookLog, webhookID, pagination.Limit+pagination.Offset)
+	}
+
+	err := p.db.Query(totalCountQuery).Consistency(gocql.One).Scan(&paginationClone.Total)
+	if err != nil {
+		return nil, err
+	}
+
+	scanner := p.db.Query(query).Iter().Scanner()
+	counter := int64(0)
+	for scanner.Next() {
+		if counter >= pagination.Offset {
+			var webhookLog models.WebhookLog
+			err := scanner.Scan(&webhookLog.ID, &webhookLog.HttpStatus, &webhookLog.Response, &webhookLog.Request, &webhookLog.WebhookID, &webhookLog.CreatedAt, &webhookLog.UpdatedAt)
+			if err != nil {
+				return nil, err
+			}
+			webhookLogs = append(webhookLogs, webhookLog.AsAPIWebhookLog())
+		}
+		counter++
+	}
+
+	return &model.WebhookLogs{
+		Pagination:  &paginationClone,
+		WebhookLogs: webhookLogs,
+	}, nil
+}

server/db/providers/mongodb/email_template.go

@@ -0,0 +1,115 @@
+package mongodb
+
+import (
+	"context"
+	"time"
+
+	"github.com/authorizerdev/authorizer/server/db/models"
+	"github.com/authorizerdev/authorizer/server/graph/model"
+	"github.com/google/uuid"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/mongo/options"
+)
+
+// AddEmailTemplate to add EmailTemplate
+func (p *provider) AddEmailTemplate(ctx context.Context, emailTemplate models.EmailTemplate) (*model.EmailTemplate, error) {
+	if emailTemplate.ID == "" {
+		emailTemplate.ID = uuid.New().String()
+	}
+
+	emailTemplate.Key = emailTemplate.ID
+	emailTemplate.CreatedAt = time.Now().Unix()
+	emailTemplate.UpdatedAt = time.Now().Unix()
+
+	emailTemplateCollection := p.db.Collection(models.Collections.EmailTemplate, options.Collection())
+	_, err := emailTemplateCollection.InsertOne(ctx, emailTemplate)
+	if err != nil {
+		return nil, err
+	}
+	return emailTemplate.AsAPIEmailTemplate(), nil
+}
+
+// UpdateEmailTemplate to update EmailTemplate
+func (p *provider) UpdateEmailTemplate(ctx context.Context, emailTemplate models.EmailTemplate) (*model.EmailTemplate, error) {
+	emailTemplate.UpdatedAt = time.Now().Unix()
+
+	emailTemplateCollection := p.db.Collection(models.Collections.EmailTemplate, options.Collection())
+	_, err := emailTemplateCollection.UpdateOne(ctx, bson.M{"_id": bson.M{"$eq": emailTemplate.ID}}, bson.M{"$set": emailTemplate}, options.MergeUpdateOptions())
+	if err != nil {
+		return nil, err
+	}
+
+	return emailTemplate.AsAPIEmailTemplate(), nil
+}
+
+// ListEmailTemplates to list EmailTemplate
+func (p *provider) ListEmailTemplate(ctx context.Context, pagination model.Pagination) (*model.EmailTemplates, error) {
+	var emailTemplates []*model.EmailTemplate
+	opts := options.Find()
+	opts.SetLimit(pagination.Limit)
+	opts.SetSkip(pagination.Offset)
+	opts.SetSort(bson.M{"created_at": -1})
+
+	paginationClone := pagination
+
+	emailTemplateCollection := p.db.Collection(models.Collections.EmailTemplate, options.Collection())
+	count, err := emailTemplateCollection.CountDocuments(ctx, bson.M{}, options.Count())
+	if err != nil {
+		return nil, err
+	}
+
+	paginationClone.Total = count
+
+	cursor, err := emailTemplateCollection.Find(ctx, bson.M{}, opts)
+	if err != nil {
+		return nil, err
+	}
+	defer cursor.Close(ctx)
+
+	for cursor.Next(ctx) {
+		var emailTemplate models.EmailTemplate
+		err := cursor.Decode(&emailTemplate)
+		if err != nil {
+			return nil, err
+		}
+		emailTemplates = append(emailTemplates, emailTemplate.AsAPIEmailTemplate())
+	}
+
+	return &model.EmailTemplates{
+		Pagination:     &paginationClone,
+		EmailTemplates: emailTemplates,
+	}, nil
+}
+
+// GetEmailTemplateByID to get EmailTemplate by id
+func (p *provider) GetEmailTemplateByID(ctx context.Context, emailTemplateID string) (*model.EmailTemplate, error) {
+	var emailTemplate models.EmailTemplate
+	emailTemplateCollection := p.db.Collection(models.Collections.EmailTemplate, options.Collection())
+	err := emailTemplateCollection.FindOne(ctx, bson.M{"_id": emailTemplateID}).Decode(&emailTemplate)
+	if err != nil {
+		return nil, err
+	}
+	return emailTemplate.AsAPIEmailTemplate(), nil
+}
+
+// GetEmailTemplateByEventName to get EmailTemplate by event_name
+func (p *provider) GetEmailTemplateByEventName(ctx context.Context, eventName string) (*model.EmailTemplate, error) {
+	var emailTemplate models.EmailTemplate
+	emailTemplateCollection := p.db.Collection(models.Collections.EmailTemplate, options.Collection())
+	err := emailTemplateCollection.FindOne(ctx, bson.M{"event_name": eventName}).Decode(&emailTemplate)
+	if err != nil {
+		return nil, err
+	}
+	return emailTemplate.AsAPIEmailTemplate(), nil
+}
+
+// DeleteEmailTemplate to delete EmailTemplate
+func (p *provider) DeleteEmailTemplate(ctx context.Context, emailTemplate *model.EmailTemplate) error {
+	emailTemplateCollection := p.db.Collection(models.Collections.EmailTemplate, options.Collection())
+	_, err := emailTemplateCollection.DeleteOne(nil, bson.M{"_id": emailTemplate.ID}, options.Delete())
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

server/db/providers/mongodb/env.go

@@ -1,6 +1,7 @@
 package mongodb
 
 import (
+	"context"
 	"fmt"
 	"time"
 
@@ -11,7 +12,7 @@ import (
 )
 
 // AddEnv to save environment information in database
-func (p *provider) AddEnv(env models.Env) (models.Env, error) {
+func (p *provider) AddEnv(ctx context.Context, env models.Env) (models.Env, error) {
 	if env.ID == "" {
 		env.ID = uuid.New().String()
 	}
@@ -20,7 +21,7 @@ func (p *provider) AddEnv(env models.Env) (models.Env, error) {
 	env.UpdatedAt = time.Now().Unix()
 	env.Key = env.ID
 	configCollection := p.db.Collection(models.Collections.Env, options.Collection())
-	_, err := configCollection.InsertOne(nil, env)
+	_, err := configCollection.InsertOne(ctx, env)
 	if err != nil {
 		return env, err
 	}
@@ -28,10 +29,10 @@ func (p *provider) AddEnv(env models.Env) (models.Env, error) {
 }
 
 // UpdateEnv to update environment information in database
-func (p *provider) UpdateEnv(env models.Env) (models.Env, error) {
+func (p *provider) UpdateEnv(ctx context.Context, env models.Env) (models.Env, error) {
 	env.UpdatedAt = time.Now().Unix()
 	configCollection := p.db.Collection(models.Collections.Env, options.Collection())
-	_, err := configCollection.UpdateOne(nil, bson.M{"_id": bson.M{"$eq": env.ID}}, bson.M{"$set": env}, options.MergeUpdateOptions())
+	_, err := configCollection.UpdateOne(ctx, bson.M{"_id": bson.M{"$eq": env.ID}}, bson.M{"$set": env}, options.MergeUpdateOptions())
 	if err != nil {
 		return env, err
 	}
@@ -39,14 +40,14 @@ func (p *provider) UpdateEnv(env models.Env) (models.Env, error) {
 }
 
 // GetEnv to get environment information from database
-func (p *provider) GetEnv() (models.Env, error) {
+func (p *provider) GetEnv(ctx context.Context) (models.Env, error) {
 	var env models.Env
 	configCollection := p.db.Collection(models.Collections.Env, options.Collection())
-	cursor, err := configCollection.Find(nil, bson.M{}, options.Find())
+	cursor, err := configCollection.Find(ctx, bson.M{}, options.Find())
 	if err != nil {
 		return env, err
 	}
-	defer cursor.Close(nil)
+	defer cursor.Close(ctx)
 
 	for cursor.Next(nil) {
 		err := cursor.Decode(&env)

server/db/providers/mongodb/provider.go

@@ -83,6 +83,33 @@ func NewProvider() (*provider, error) {
 
 	mongodb.CreateCollection(ctx, models.Collections.Env, options.CreateCollection())
 
+	mongodb.CreateCollection(ctx, models.Collections.Webhook, options.CreateCollection())
+	webhookCollection := mongodb.Collection(models.Collections.Webhook, options.Collection())
+	webhookCollection.Indexes().CreateMany(ctx, []mongo.IndexModel{
+		{
+			Keys:    bson.M{"event_name": 1},
+			Options: options.Index().SetUnique(true).SetSparse(true),
+		},
+	}, options.CreateIndexes())
+
+	mongodb.CreateCollection(ctx, models.Collections.WebhookLog, options.CreateCollection())
+	webhookLogCollection := mongodb.Collection(models.Collections.WebhookLog, options.Collection())
+	webhookLogCollection.Indexes().CreateMany(ctx, []mongo.IndexModel{
+		{
+			Keys:    bson.M{"webhook_id": 1},
+			Options: options.Index().SetSparse(true),
+		},
+	}, options.CreateIndexes())
+
+	mongodb.CreateCollection(ctx, models.Collections.EmailTemplate, options.CreateCollection())
+	emailTemplateCollection := mongodb.Collection(models.Collections.EmailTemplate, options.Collection())
+	emailTemplateCollection.Indexes().CreateMany(ctx, []mongo.IndexModel{
+		{
+			Keys:    bson.M{"event_name": 1},
+			Options: options.Index().SetUnique(true).SetSparse(true),
+		},
+	}, options.CreateIndexes())
+
 	return &provider{
 		db: mongodb,
 	}, nil

server/db/providers/mongodb/session.go

@@ -1,16 +1,16 @@
 package mongodb
 
 import (
+	"context"
 	"time"
 
 	"github.com/authorizerdev/authorizer/server/db/models"
 	"github.com/google/uuid"
-	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo/options"
 )
 
 // AddSession to save session information in database
-func (p *provider) AddSession(session models.Session) error {
+func (p *provider) AddSession(ctx context.Context, session models.Session) error {
 	if session.ID == "" {
 		session.ID = uuid.New().String()
 	}
@@ -19,17 +19,7 @@ func (p *provider) AddSession(session models.Session) error {
 	session.CreatedAt = time.Now().Unix()
 	session.UpdatedAt = time.Now().Unix()
 	sessionCollection := p.db.Collection(models.Collections.Session, options.Collection())
-	_, err := sessionCollection.InsertOne(nil, session)
+	_, err := sessionCollection.InsertOne(ctx, session)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-// DeleteSession to delete session information from database
-func (p *provider) DeleteSession(userId string) error {
-	sessionCollection := p.db.Collection(models.Collections.Session, options.Collection())
-	_, err := sessionCollection.DeleteMany(nil, bson.M{"user_id": userId}, options.Delete())
 	if err != nil {
 		return err
 	}

server/db/providers/mongodb/user.go

@@ -1,6 +1,7 @@
 package mongodb
 
 import (
+	"context"
 	"time"
 
 	"github.com/authorizerdev/authorizer/server/constants"
@@ -13,7 +14,7 @@ import (
 )
 
 // AddUser to save user information in database
-func (p *provider) AddUser(user models.User) (models.User, error) {
+func (p *provider) AddUser(ctx context.Context, user models.User) (models.User, error) {
 	if user.ID == "" {
 		user.ID = uuid.New().String()
 	}
@@ -29,7 +30,7 @@ func (p *provider) AddUser(user models.User) (models.User, error) {
 	user.UpdatedAt = time.Now().Unix()
 	user.Key = user.ID
 	userCollection := p.db.Collection(models.Collections.User, options.Collection())
-	_, err := userCollection.InsertOne(nil, user)
+	_, err := userCollection.InsertOne(ctx, user)
 	if err != nil {
 		return user, err
 	}
@@ -38,10 +39,10 @@ func (p *provider) AddUser(user models.User) (models.User, error) {
 }
 
 // UpdateUser to update user information in database
-func (p *provider) UpdateUser(user models.User) (models.User, error) {
+func (p *provider) UpdateUser(ctx context.Context, user models.User) (models.User, error) {
 	user.UpdatedAt = time.Now().Unix()
 	userCollection := p.db.Collection(models.Collections.User, options.Collection())
-	_, err := userCollection.UpdateOne(nil, bson.M{"_id": bson.M{"$eq": user.ID}}, bson.M{"$set": user}, options.MergeUpdateOptions())
+	_, err := userCollection.UpdateOne(ctx, bson.M{"_id": bson.M{"$eq": user.ID}}, bson.M{"$set": user}, options.MergeUpdateOptions())
 	if err != nil {
 		return user, err
 	}
@@ -49,9 +50,15 @@ func (p *provider) UpdateUser(user models.User) (models.User, error) {
 }
 
 // DeleteUser to delete user information from database
-func (p *provider) DeleteUser(user models.User) error {
+func (p *provider) DeleteUser(ctx context.Context, user models.User) error {
 	userCollection := p.db.Collection(models.Collections.User, options.Collection())
-	_, err := userCollection.DeleteOne(nil, bson.M{"_id": user.ID}, options.Delete())
+	_, err := userCollection.DeleteOne(ctx, bson.M{"_id": user.ID}, options.Delete())
+	if err != nil {
+		return err
+	}
+
+	sessionCollection := p.db.Collection(models.Collections.Session, options.Collection())
+	_, err = sessionCollection.DeleteMany(ctx, bson.M{"user_id": user.ID}, options.Delete())
 	if err != nil {
 		return err
 	}
@@ -60,7 +67,7 @@ func (p *provider) DeleteUser(user models.User) error {
 }
 
 // ListUsers to get list of users from database
-func (p *provider) ListUsers(pagination model.Pagination) (*model.Users, error) {
+func (p *provider) ListUsers(ctx context.Context, pagination model.Pagination) (*model.Users, error) {
 	var users []*model.User
 	opts := options.Find()
 	opts.SetLimit(pagination.Limit)
@@ -70,20 +77,20 @@ func (p *provider) ListUsers(pagination model.Pagination) (*model.Users, error)
 	paginationClone := pagination
 
 	userCollection := p.db.Collection(models.Collections.User, options.Collection())
-	count, err := userCollection.CountDocuments(nil, bson.M{}, options.Count())
+	count, err := userCollection.CountDocuments(ctx, bson.M{}, options.Count())
 	if err != nil {
 		return nil, err
 	}
 
 	paginationClone.Total = count
 
-	cursor, err := userCollection.Find(nil, bson.M{}, opts)
+	cursor, err := userCollection.Find(ctx, bson.M{}, opts)
 	if err != nil {
 		return nil, err
 	}
-	defer cursor.Close(nil)
+	defer cursor.Close(ctx)
 
-	for cursor.Next(nil) {
+	for cursor.Next(ctx) {
 		var user models.User
 		err := cursor.Decode(&user)
 		if err != nil {
@@ -99,10 +106,10 @@ func (p *provider) ListUsers(pagination model.Pagination) (*model.Users, error)
 }
 
 // GetUserByEmail to get user information from database using email address
-func (p *provider) GetUserByEmail(email string) (models.User, error) {
+func (p *provider) GetUserByEmail(ctx context.Context, email string) (models.User, error) {
 	var user models.User
 	userCollection := p.db.Collection(models.Collections.User, options.Collection())
-	err := userCollection.FindOne(nil, bson.M{"email": email}).Decode(&user)
+	err := userCollection.FindOne(ctx, bson.M{"email": email}).Decode(&user)
 	if err != nil {
 		return user, err
 	}
@@ -111,11 +118,11 @@ func (p *provider) GetUserByEmail(email string) (models.User, error) {
 }
 
 // GetUserByID to get user information from database using user ID
-func (p *provider) GetUserByID(id string) (models.User, error) {
+func (p *provider) GetUserByID(ctx context.Context, id string) (models.User, error) {
 	var user models.User
 
 	userCollection := p.db.Collection(models.Collections.User, options.Collection())
-	err := userCollection.FindOne(nil, bson.M{"_id": id}).Decode(&user)
+	err := userCollection.FindOne(ctx, bson.M{"_id": id}).Decode(&user)
 	if err != nil {
 		return user, err
 	}

server/db/providers/mongodb/verification_requests.go

@@ -1,6 +1,7 @@
 package mongodb
 
 import (
+	"context"
 	"time"
 
 	"github.com/authorizerdev/authorizer/server/db/models"
@@ -11,7 +12,7 @@ import (
 )
 
 // AddVerification to save verification request in database
-func (p *provider) AddVerificationRequest(verificationRequest models.VerificationRequest) (models.VerificationRequest, error) {
+func (p *provider) AddVerificationRequest(ctx context.Context, verificationRequest models.VerificationRequest) (models.VerificationRequest, error) {
 	if verificationRequest.ID == "" {
 		verificationRequest.ID = uuid.New().String()
 
@@ -19,7 +20,7 @@ func (p *provider) AddVerificationRequest(verificationRequest models.Verificatio
 		verificationRequest.UpdatedAt = time.Now().Unix()
 		verificationRequest.Key = verificationRequest.ID
 		verificationRequestCollection := p.db.Collection(models.Collections.VerificationRequest, options.Collection())
-		_, err := verificationRequestCollection.InsertOne(nil, verificationRequest)
+		_, err := verificationRequestCollection.InsertOne(ctx, verificationRequest)
 		if err != nil {
 			return verificationRequest, err
 		}
@@ -29,11 +30,11 @@ func (p *provider) AddVerificationRequest(verificationRequest models.Verificatio
 }
 
 // GetVerificationRequestByToken to get verification request from database using token
-func (p *provider) GetVerificationRequestByToken(token string) (models.VerificationRequest, error) {
+func (p *provider) GetVerificationRequestByToken(ctx context.Context, token string) (models.VerificationRequest, error) {
 	var verificationRequest models.VerificationRequest
 
 	verificationRequestCollection := p.db.Collection(models.Collections.VerificationRequest, options.Collection())
-	err := verificationRequestCollection.FindOne(nil, bson.M{"token": token}).Decode(&verificationRequest)
+	err := verificationRequestCollection.FindOne(ctx, bson.M{"token": token}).Decode(&verificationRequest)
 	if err != nil {
 		return verificationRequest, err
 	}
@@ -42,11 +43,11 @@ func (p *provider) GetVerificationRequestByToken(token string) (models.Verificat
 }
 
 // GetVerificationRequestByEmail to get verification request by email from database
-func (p *provider) GetVerificationRequestByEmail(email string, identifier string) (models.VerificationRequest, error) {
+func (p *provider) GetVerificationRequestByEmail(ctx context.Context, email string, identifier string) (models.VerificationRequest, error) {
 	var verificationRequest models.VerificationRequest
 
 	verificationRequestCollection := p.db.Collection(models.Collections.VerificationRequest, options.Collection())
-	err := verificationRequestCollection.FindOne(nil, bson.M{"email": email, "identifier": identifier}).Decode(&verificationRequest)
+	err := verificationRequestCollection.FindOne(ctx, bson.M{"email": email, "identifier": identifier}).Decode(&verificationRequest)
 	if err != nil {
 		return verificationRequest, err
 	}
@@ -55,7 +56,7 @@ func (p *provider) GetVerificationRequestByEmail(email string, identifier string
 }
 
 // ListVerificationRequests to get list of verification requests from database
-func (p *provider) ListVerificationRequests(pagination model.Pagination) (*model.VerificationRequests, error) {
+func (p *provider) ListVerificationRequests(ctx context.Context, pagination model.Pagination) (*model.VerificationRequests, error) {
 	var verificationRequests []*model.VerificationRequest
 
 	opts := options.Find()
@@ -65,17 +66,17 @@ func (p *provider) ListVerificationRequests(pagination model.Pagination) (*model
 
 	verificationRequestCollection := p.db.Collection(models.Collections.VerificationRequest, options.Collection())
 
-	verificationRequestCollectionCount, err := verificationRequestCollection.CountDocuments(nil, bson.M{})
+	verificationRequestCollectionCount, err := verificationRequestCollection.CountDocuments(ctx, bson.M{})
 	paginationClone := pagination
 	paginationClone.Total = verificationRequestCollectionCount
 
-	cursor, err := verificationRequestCollection.Find(nil, bson.M{}, opts)
+	cursor, err := verificationRequestCollection.Find(ctx, bson.M{}, opts)
 	if err != nil {
 		return nil, err
 	}
-	defer cursor.Close(nil)
+	defer cursor.Close(ctx)
 
-	for cursor.Next(nil) {
+	for cursor.Next(ctx) {
 		var verificationRequest models.VerificationRequest
 		err := cursor.Decode(&verificationRequest)
 		if err != nil {
@@ -91,9 +92,9 @@ func (p *provider) ListVerificationRequests(pagination model.Pagination) (*model
 }
 
 // DeleteVerificationRequest to delete verification request from database
-func (p *provider) DeleteVerificationRequest(verificationRequest models.VerificationRequest) error {
+func (p *provider) DeleteVerificationRequest(ctx context.Context, verificationRequest models.VerificationRequest) error {
 	verificationRequestCollection := p.db.Collection(models.Collections.VerificationRequest, options.Collection())
-	_, err := verificationRequestCollection.DeleteOne(nil, bson.M{"_id": verificationRequest.ID}, options.Delete())
+	_, err := verificationRequestCollection.DeleteOne(ctx, bson.M{"_id": verificationRequest.ID}, options.Delete())
 	if err != nil {
 		return err
 	}

server/db/providers/mongodb/webhook.go

@@ -0,0 +1,120 @@
+package mongodb
+
+import (
+	"context"
+	"time"
+
+	"github.com/authorizerdev/authorizer/server/db/models"
+	"github.com/authorizerdev/authorizer/server/graph/model"
+	"github.com/google/uuid"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/mongo/options"
+)
+
+// AddWebhook to add webhook
+func (p *provider) AddWebhook(ctx context.Context, webhook models.Webhook) (*model.Webhook, error) {
+	if webhook.ID == "" {
+		webhook.ID = uuid.New().String()
+	}
+
+	webhook.Key = webhook.ID
+	webhook.CreatedAt = time.Now().Unix()
+	webhook.UpdatedAt = time.Now().Unix()
+
+	webhookCollection := p.db.Collection(models.Collections.Webhook, options.Collection())
+	_, err := webhookCollection.InsertOne(ctx, webhook)
+	if err != nil {
+		return nil, err
+	}
+	return webhook.AsAPIWebhook(), nil
+}
+
+// UpdateWebhook to update webhook
+func (p *provider) UpdateWebhook(ctx context.Context, webhook models.Webhook) (*model.Webhook, error) {
+	webhook.UpdatedAt = time.Now().Unix()
+	webhookCollection := p.db.Collection(models.Collections.Webhook, options.Collection())
+	_, err := webhookCollection.UpdateOne(ctx, bson.M{"_id": bson.M{"$eq": webhook.ID}}, bson.M{"$set": webhook}, options.MergeUpdateOptions())
+	if err != nil {
+		return nil, err
+	}
+
+	return webhook.AsAPIWebhook(), nil
+}
+
+// ListWebhooks to list webhook
+func (p *provider) ListWebhook(ctx context.Context, pagination model.Pagination) (*model.Webhooks, error) {
+	var webhooks []*model.Webhook
+	opts := options.Find()
+	opts.SetLimit(pagination.Limit)
+	opts.SetSkip(pagination.Offset)
+	opts.SetSort(bson.M{"created_at": -1})
+
+	paginationClone := pagination
+
+	webhookCollection := p.db.Collection(models.Collections.Webhook, options.Collection())
+	count, err := webhookCollection.CountDocuments(ctx, bson.M{}, options.Count())
+	if err != nil {
+		return nil, err
+	}
+
+	paginationClone.Total = count
+
+	cursor, err := webhookCollection.Find(ctx, bson.M{}, opts)
+	if err != nil {
+		return nil, err
+	}
+	defer cursor.Close(ctx)
+
+	for cursor.Next(ctx) {
+		var webhook models.Webhook
+		err := cursor.Decode(&webhook)
+		if err != nil {
+			return nil, err
+		}
+		webhooks = append(webhooks, webhook.AsAPIWebhook())
+	}
+
+	return &model.Webhooks{
+		Pagination: &paginationClone,
+		Webhooks:   webhooks,
+	}, nil
+}
+
+// GetWebhookByID to get webhook by id
+func (p *provider) GetWebhookByID(ctx context.Context, webhookID string) (*model.Webhook, error) {
+	var webhook models.Webhook
+	webhookCollection := p.db.Collection(models.Collections.Webhook, options.Collection())
+	err := webhookCollection.FindOne(ctx, bson.M{"_id": webhookID}).Decode(&webhook)
+	if err != nil {
+		return nil, err
+	}
+	return webhook.AsAPIWebhook(), nil
+}
+
+// GetWebhookByEventName to get webhook by event_name
+func (p *provider) GetWebhookByEventName(ctx context.Context, eventName string) (*model.Webhook, error) {
+	var webhook models.Webhook
+	webhookCollection := p.db.Collection(models.Collections.Webhook, options.Collection())
+	err := webhookCollection.FindOne(ctx, bson.M{"event_name": eventName}).Decode(&webhook)
+	if err != nil {
+		return nil, err
+	}
+	return webhook.AsAPIWebhook(), nil
+}
+
+// DeleteWebhook to delete webhook
+func (p *provider) DeleteWebhook(ctx context.Context, webhook *model.Webhook) error {
+	webhookCollection := p.db.Collection(models.Collections.Webhook, options.Collection())
+	_, err := webhookCollection.DeleteOne(nil, bson.M{"_id": webhook.ID}, options.Delete())
+	if err != nil {
+		return err
+	}
+
+	webhookLogCollection := p.db.Collection(models.Collections.WebhookLog, options.Collection())
+	_, err = webhookLogCollection.DeleteMany(nil, bson.M{"webhook_id": webhook.ID}, options.Delete())
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

server/db/providers/mongodb/webhook_log.go

@@ -0,0 +1,74 @@
+package mongodb
+
+import (
+	"context"
+	"time"
+
+	"github.com/authorizerdev/authorizer/server/db/models"
+	"github.com/authorizerdev/authorizer/server/graph/model"
+	"github.com/google/uuid"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/mongo/options"
+)
+
+// AddWebhookLog to add webhook log
+func (p *provider) AddWebhookLog(ctx context.Context, webhookLog models.WebhookLog) (*model.WebhookLog, error) {
+	if webhookLog.ID == "" {
+		webhookLog.ID = uuid.New().String()
+	}
+
+	webhookLog.Key = webhookLog.ID
+	webhookLog.CreatedAt = time.Now().Unix()
+	webhookLog.UpdatedAt = time.Now().Unix()
+
+	webhookLogCollection := p.db.Collection(models.Collections.WebhookLog, options.Collection())
+	_, err := webhookLogCollection.InsertOne(ctx, webhookLog)
+	if err != nil {
+		return nil, err
+	}
+	return webhookLog.AsAPIWebhookLog(), nil
+}
+
+// ListWebhookLogs to list webhook logs
+func (p *provider) ListWebhookLogs(ctx context.Context, pagination model.Pagination, webhookID string) (*model.WebhookLogs, error) {
+	webhookLogs := []*model.WebhookLog{}
+	opts := options.Find()
+	opts.SetLimit(pagination.Limit)
+	opts.SetSkip(pagination.Offset)
+	opts.SetSort(bson.M{"created_at": -1})
+
+	paginationClone := pagination
+	query := bson.M{}
+
+	if webhookID != "" {
+		query = bson.M{"webhook_id": webhookID}
+	}
+
+	webhookLogCollection := p.db.Collection(models.Collections.WebhookLog, options.Collection())
+	count, err := webhookLogCollection.CountDocuments(ctx, query, options.Count())
+	if err != nil {
+		return nil, err
+	}
+
+	paginationClone.Total = count
+
+	cursor, err := webhookLogCollection.Find(ctx, query, opts)
+	if err != nil {
+		return nil, err
+	}
+	defer cursor.Close(ctx)
+
+	for cursor.Next(ctx) {
+		var webhookLog models.WebhookLog
+		err := cursor.Decode(&webhookLog)
+		if err != nil {
+			return nil, err
+		}
+		webhookLogs = append(webhookLogs, webhookLog.AsAPIWebhookLog())
+	}
+
+	return &model.WebhookLogs{
+		Pagination:  &paginationClone,
+		WebhookLogs: webhookLogs,
+	}, nil
+}

server/db/providers/provider_template/email_template.go

@@ -0,0 +1,48 @@
+package provider_template
+
+import (
+	"context"
+	"time"
+
+	"github.com/authorizerdev/authorizer/server/db/models"
+	"github.com/authorizerdev/authorizer/server/graph/model"
+	"github.com/google/uuid"
+)
+
+// AddEmailTemplate to add EmailTemplate
+func (p *provider) AddEmailTemplate(ctx context.Context, emailTemplate models.EmailTemplate) (*model.EmailTemplate, error) {
+	if emailTemplate.ID == "" {
+		emailTemplate.ID = uuid.New().String()
+	}
+
+	emailTemplate.Key = emailTemplate.ID
+	emailTemplate.CreatedAt = time.Now().Unix()
+	emailTemplate.UpdatedAt = time.Now().Unix()
+	return emailTemplate.AsAPIEmailTemplate(), nil
+}
+
+// UpdateEmailTemplate to update EmailTemplate
+func (p *provider) UpdateEmailTemplate(ctx context.Context, emailTemplate models.EmailTemplate) (*model.EmailTemplate, error) {
+	emailTemplate.UpdatedAt = time.Now().Unix()
+	return emailTemplate.AsAPIEmailTemplate(), nil
+}
+
+// ListEmailTemplates to list EmailTemplate
+func (p *provider) ListEmailTemplate(ctx context.Context, pagination model.Pagination) (*model.EmailTemplates, error) {
+	return nil, nil
+}
+
+// GetEmailTemplateByID to get EmailTemplate by id
+func (p *provider) GetEmailTemplateByID(ctx context.Context, emailTemplateID string) (*model.EmailTemplate, error) {
+	return nil, nil
+}
+
+// GetEmailTemplateByEventName to get EmailTemplate by event_name
+func (p *provider) GetEmailTemplateByEventName(ctx context.Context, eventName string) (*model.EmailTemplate, error) {
+	return nil, nil
+}
+
+// DeleteEmailTemplate to delete EmailTemplate
+func (p *provider) DeleteEmailTemplate(ctx context.Context, emailTemplate *model.EmailTemplate) error {
+	return nil
+}

server/db/providers/provider_template/env.go

@@ -1,6 +1,7 @@
 package provider_template
 
 import (
+	"context"
 	"time"
 
 	"github.com/authorizerdev/authorizer/server/db/models"
@@ -8,7 +9,7 @@ import (
 )
 
 // AddEnv to save environment information in database
-func (p *provider) AddEnv(env models.Env) (models.Env, error) {
+func (p *provider) AddEnv(ctx context.Context, env models.Env) (models.Env, error) {
 	if env.ID == "" {
 		env.ID = uuid.New().String()
 	}
@@ -19,13 +20,13 @@ func (p *provider) AddEnv(env models.Env) (models.Env, error) {
 }
 
 // UpdateEnv to update environment information in database
-func (p *provider) UpdateEnv(env models.Env) (models.Env, error) {
+func (p *provider) UpdateEnv(ctx context.Context, env models.Env) (models.Env, error) {
 	env.UpdatedAt = time.Now().Unix()
 	return env, nil
 }
 
 // GetEnv to get environment information from database
-func (p *provider) GetEnv() (models.Env, error) {
+func (p *provider) GetEnv(ctx context.Context) (models.Env, error) {
 	var env models.Env
 
 	return env, nil

server/db/providers/provider_template/session.go

@@ -1,6 +1,7 @@
 package provider_template
 
 import (
+	"context"
 	"time"
 
 	"github.com/authorizerdev/authorizer/server/db/models"
@@ -8,7 +9,7 @@ import (
 )
 
 // AddSession to save session information in database
-func (p *provider) AddSession(session models.Session) error {
+func (p *provider) AddSession(ctx context.Context, session models.Session) error {
 	if session.ID == "" {
 		session.ID = uuid.New().String()
 	}
@@ -19,6 +20,6 @@ func (p *provider) AddSession(session models.Session) error {
 }
 
 // DeleteSession to delete session information from database
-func (p *provider) DeleteSession(userId string) error {
+func (p *provider) DeleteSession(ctx context.Context, userId string) error {
 	return nil
 }

server/db/providers/provider_template/user.go

@@ -1,6 +1,7 @@
 package provider_template
 
 import (
+	"context"
 	"time"
 
 	"github.com/authorizerdev/authorizer/server/constants"
@@ -11,7 +12,7 @@ import (
 )
 
 // AddUser to save user information in database
-func (p *provider) AddUser(user models.User) (models.User, error) {
+func (p *provider) AddUser(ctx context.Context, user models.User) (models.User, error) {
 	if user.ID == "" {
 		user.ID = uuid.New().String()
 	}
@@ -31,30 +32,30 @@ func (p *provider) AddUser(user models.User) (models.User, error) {
 }
 
 // UpdateUser to update user information in database
-func (p *provider) UpdateUser(user models.User) (models.User, error) {
+func (p *provider) UpdateUser(ctx context.Context, user models.User) (models.User, error) {
 	user.UpdatedAt = time.Now().Unix()
 	return user, nil
 }
 
 // DeleteUser to delete user information from database
-func (p *provider) DeleteUser(user models.User) error {
+func (p *provider) DeleteUser(ctx context.Context, user models.User) error {
 	return nil
 }
 
 // ListUsers to get list of users from database
-func (p *provider) ListUsers(pagination model.Pagination) (*model.Users, error) {
+func (p *provider) ListUsers(ctx context.Context, pagination model.Pagination) (*model.Users, error) {
 	return nil, nil
 }
 
 // GetUserByEmail to get user information from database using email address
-func (p *provider) GetUserByEmail(email string) (models.User, error) {
+func (p *provider) GetUserByEmail(ctx context.Context, email string) (models.User, error) {
 	var user models.User
 
 	return user, nil
 }
 
 // GetUserByID to get user information from database using user ID
-func (p *provider) GetUserByID(id string) (models.User, error) {
+func (p *provider) GetUserByID(ctx context.Context, id string) (models.User, error) {
 	var user models.User
 
 	return user, nil

server/db/providers/provider_template/verification_requests.go

@@ -1,6 +1,7 @@
 package provider_template
 
 import (
+	"context"
 	"time"
 
 	"github.com/authorizerdev/authorizer/server/db/models"
@@ -9,7 +10,7 @@ import (
 )
 
 // AddVerification to save verification request in database
-func (p *provider) AddVerificationRequest(verificationRequest models.VerificationRequest) (models.VerificationRequest, error) {
+func (p *provider) AddVerificationRequest(ctx context.Context, verificationRequest models.VerificationRequest) (models.VerificationRequest, error) {
 	if verificationRequest.ID == "" {
 		verificationRequest.ID = uuid.New().String()
 	}
@@ -21,25 +22,25 @@ func (p *provider) AddVerificationRequest(verificationRequest models.Verificatio
 }
 
 // GetVerificationRequestByToken to get verification request from database using token
-func (p *provider) GetVerificationRequestByToken(token string) (models.VerificationRequest, error) {
+func (p *provider) GetVerificationRequestByToken(ctx context.Context, token string) (models.VerificationRequest, error) {
 	var verificationRequest models.VerificationRequest
 
 	return verificationRequest, nil
 }
 
 // GetVerificationRequestByEmail to get verification request by email from database
-func (p *provider) GetVerificationRequestByEmail(email string, identifier string) (models.VerificationRequest, error) {
+func (p *provider) GetVerificationRequestByEmail(ctx context.Context, email string, identifier string) (models.VerificationRequest, error) {
 	var verificationRequest models.VerificationRequest
 
 	return verificationRequest, nil
 }
 
 // ListVerificationRequests to get list of verification requests from database
-func (p *provider) ListVerificationRequests(pagination model.Pagination) (*model.VerificationRequests, error) {
+func (p *provider) ListVerificationRequests(ctx context.Context, pagination model.Pagination) (*model.VerificationRequests, error) {
 	return nil, nil
 }
 
 // DeleteVerificationRequest to delete verification request from database
-func (p *provider) DeleteVerificationRequest(verificationRequest models.VerificationRequest) error {
+func (p *provider) DeleteVerificationRequest(ctx context.Context, verificationRequest models.VerificationRequest) error {
 	return nil
 }

server/db/providers/provider_template/webhook.go

@@ -0,0 +1,49 @@
+package provider_template
+
+import (
+	"context"
+	"time"
+
+	"github.com/authorizerdev/authorizer/server/db/models"
+	"github.com/authorizerdev/authorizer/server/graph/model"
+	"github.com/google/uuid"
+)
+
+// AddWebhook to add webhook
+func (p *provider) AddWebhook(ctx context.Context, webhook models.Webhook) (*model.Webhook, error) {
+	if webhook.ID == "" {
+		webhook.ID = uuid.New().String()
+	}
+
+	webhook.Key = webhook.ID
+	webhook.CreatedAt = time.Now().Unix()
+	webhook.UpdatedAt = time.Now().Unix()
+	return webhook.AsAPIWebhook(), nil
+}
+
+// UpdateWebhook to update webhook
+func (p *provider) UpdateWebhook(ctx context.Context, webhook models.Webhook) (*model.Webhook, error) {
+	webhook.UpdatedAt = time.Now().Unix()
+	return webhook.AsAPIWebhook(), nil
+}
+
+// ListWebhooks to list webhook
+func (p *provider) ListWebhook(ctx context.Context, pagination model.Pagination) (*model.Webhooks, error) {
+	return nil, nil
+}
+
+// GetWebhookByID to get webhook by id
+func (p *provider) GetWebhookByID(ctx context.Context, webhookID string) (*model.Webhook, error) {
+	return nil, nil
+}
+
+// GetWebhookByEventName to get webhook by event_name
+func (p *provider) GetWebhookByEventName(ctx context.Context, eventName string) (*model.Webhook, error) {
+	return nil, nil
+}
+
+// DeleteWebhook to delete webhook
+func (p *provider) DeleteWebhook(ctx context.Context, webhook *model.Webhook) error {
+	// Also delete webhook logs for given webhook id
+	return nil
+}

server/db/providers/provider_template/webhook_log.go

@@ -0,0 +1,27 @@
+package provider_template
+
+import (
+	"context"
+	"time"
+
+	"github.com/authorizerdev/authorizer/server/db/models"
+	"github.com/authorizerdev/authorizer/server/graph/model"
+	"github.com/google/uuid"
+)
+
+// AddWebhookLog to add webhook log
+func (p *provider) AddWebhookLog(ctx context.Context, webhookLog models.WebhookLog) (*model.WebhookLog, error) {
+	if webhookLog.ID == "" {
+		webhookLog.ID = uuid.New().String()
+	}
+
+	webhookLog.Key = webhookLog.ID
+	webhookLog.CreatedAt = time.Now().Unix()
+	webhookLog.UpdatedAt = time.Now().Unix()
+	return webhookLog.AsAPIWebhookLog(), nil
+}
+
+// ListWebhookLogs to list webhook logs
+func (p *provider) ListWebhookLogs(ctx context.Context, pagination model.Pagination, webhookID string) (*model.WebhookLogs, error) {
+	return nil, nil
+}

server/db/providers/providers.go

@@ -1,44 +1,75 @@
 package providers
 
 import (
+	"context"
+
 	"github.com/authorizerdev/authorizer/server/db/models"
 	"github.com/authorizerdev/authorizer/server/graph/model"
 )
 
 type Provider interface {
 	// AddUser to save user information in database
-	AddUser(user models.User) (models.User, error)
+	AddUser(ctx context.Context, user models.User) (models.User, error)
 	// UpdateUser to update user information in database
-	UpdateUser(user models.User) (models.User, error)
+	UpdateUser(ctx context.Context, user models.User) (models.User, error)
 	// DeleteUser to delete user information from database
-	DeleteUser(user models.User) error
+	DeleteUser(ctx context.Context, user models.User) error
 	// ListUsers to get list of users from database
-	ListUsers(pagination model.Pagination) (*model.Users, error)
+	ListUsers(ctx context.Context, pagination model.Pagination) (*model.Users, error)
 	// GetUserByEmail to get user information from database using email address
-	GetUserByEmail(email string) (models.User, error)
+	GetUserByEmail(ctx context.Context, email string) (models.User, error)
 	// GetUserByID to get user information from database using user ID
-	GetUserByID(id string) (models.User, error)
+	GetUserByID(ctx context.Context, id string) (models.User, error)
 
 	// AddVerification to save verification request in database
-	AddVerificationRequest(verificationRequest models.VerificationRequest) (models.VerificationRequest, error)
+	AddVerificationRequest(ctx context.Context, verificationRequest models.VerificationRequest) (models.VerificationRequest, error)
 	// GetVerificationRequestByToken to get verification request from database using token
-	GetVerificationRequestByToken(token string) (models.VerificationRequest, error)
+	GetVerificationRequestByToken(ctx context.Context, token string) (models.VerificationRequest, error)
 	// GetVerificationRequestByEmail to get verification request by email from database
-	GetVerificationRequestByEmail(email string, identifier string) (models.VerificationRequest, error)
+	GetVerificationRequestByEmail(ctx context.Context, email string, identifier string) (models.VerificationRequest, error)
 	// ListVerificationRequests to get list of verification requests from database
-	ListVerificationRequests(pagination model.Pagination) (*model.VerificationRequests, error)
+	ListVerificationRequests(ctx context.Context, pagination model.Pagination) (*model.VerificationRequests, error)
 	// DeleteVerificationRequest to delete verification request from database
-	DeleteVerificationRequest(verificationRequest models.VerificationRequest) error
+	DeleteVerificationRequest(ctx context.Context, verificationRequest models.VerificationRequest) error
 
 	// AddSession to save session information in database
-	AddSession(session models.Session) error
+	AddSession(ctx context.Context, session models.Session) error
-	// DeleteSession to delete session information from database
-	DeleteSession(userId string) error
 
 	// AddEnv to save environment information in database
-	AddEnv(env models.Env) (models.Env, error)
+	AddEnv(ctx context.Context, env models.Env) (models.Env, error)
 	// UpdateEnv to update environment information in database
-	UpdateEnv(env models.Env) (models.Env, error)
+	UpdateEnv(ctx context.Context, env models.Env) (models.Env, error)
 	// GetEnv to get environment information from database
-	GetEnv() (models.Env, error)
+	GetEnv(ctx context.Context) (models.Env, error)
+
+	// AddWebhook to add webhook
+	AddWebhook(ctx context.Context, webhook models.Webhook) (*model.Webhook, error)
+	// UpdateWebhook to update webhook
+	UpdateWebhook(ctx context.Context, webhook models.Webhook) (*model.Webhook, error)
+	// ListWebhooks to list webhook
+	ListWebhook(ctx context.Context, pagination model.Pagination) (*model.Webhooks, error)
+	// GetWebhookByID to get webhook by id
+	GetWebhookByID(ctx context.Context, webhookID string) (*model.Webhook, error)
+	// GetWebhookByEventName to get webhook by event_name
+	GetWebhookByEventName(ctx context.Context, eventName string) (*model.Webhook, error)
+	// DeleteWebhook to delete webhook
+	DeleteWebhook(ctx context.Context, webhook *model.Webhook) error
+
+	// AddWebhookLog to add webhook log
+	AddWebhookLog(ctx context.Context, webhookLog models.WebhookLog) (*model.WebhookLog, error)
+	// ListWebhookLogs to list webhook logs
+	ListWebhookLogs(ctx context.Context, pagination model.Pagination, webhookID string) (*model.WebhookLogs, error)
+
+	// AddEmailTemplate to add EmailTemplate
+	AddEmailTemplate(ctx context.Context, emailTemplate models.EmailTemplate) (*model.EmailTemplate, error)
+	// UpdateEmailTemplate to update EmailTemplate
+	UpdateEmailTemplate(ctx context.Context, emailTemplate models.EmailTemplate) (*model.EmailTemplate, error)
+	// ListEmailTemplates to list EmailTemplate
+	ListEmailTemplate(ctx context.Context, pagination model.Pagination) (*model.EmailTemplates, error)
+	// GetEmailTemplateByID to get EmailTemplate by id
+	GetEmailTemplateByID(ctx context.Context, emailTemplateID string) (*model.EmailTemplate, error)
+	// GetEmailTemplateByEventName to get EmailTemplate by event_name
+	GetEmailTemplateByEventName(ctx context.Context, eventName string) (*model.EmailTemplate, error)
+	// DeleteEmailTemplate to delete EmailTemplate
+	DeleteEmailTemplate(ctx context.Context, emailTemplate *model.EmailTemplate) error
 }

server/db/providers/sql/email_template.go

@@ -0,0 +1,100 @@
+package sql
+
+import (
+	"context"
+	"time"
+
+	"github.com/authorizerdev/authorizer/server/db/models"
+	"github.com/authorizerdev/authorizer/server/graph/model"
+	"github.com/google/uuid"
+)
+
+// AddEmailTemplate to add EmailTemplate
+func (p *provider) AddEmailTemplate(ctx context.Context, emailTemplate models.EmailTemplate) (*model.EmailTemplate, error) {
+	if emailTemplate.ID == "" {
+		emailTemplate.ID = uuid.New().String()
+	}
+
+	emailTemplate.Key = emailTemplate.ID
+	emailTemplate.CreatedAt = time.Now().Unix()
+	emailTemplate.UpdatedAt = time.Now().Unix()
+
+	res := p.db.Create(&emailTemplate)
+	if res.Error != nil {
+		return nil, res.Error
+	}
+	return emailTemplate.AsAPIEmailTemplate(), nil
+}
+
+// UpdateEmailTemplate to update EmailTemplate
+func (p *provider) UpdateEmailTemplate(ctx context.Context, emailTemplate models.EmailTemplate) (*model.EmailTemplate, error) {
+	emailTemplate.UpdatedAt = time.Now().Unix()
+
+	res := p.db.Save(&emailTemplate)
+	if res.Error != nil {
+		return nil, res.Error
+	}
+	return emailTemplate.AsAPIEmailTemplate(), nil
+}
+
+// ListEmailTemplates to list EmailTemplate
+func (p *provider) ListEmailTemplate(ctx context.Context, pagination model.Pagination) (*model.EmailTemplates, error) {
+	var emailTemplates []models.EmailTemplate
+
+	result := p.db.Limit(int(pagination.Limit)).Offset(int(pagination.Offset)).Order("created_at DESC").Find(&emailTemplates)
+	if result.Error != nil {
+		return nil, result.Error
+	}
+
+	var total int64
+	totalRes := p.db.Model(&models.EmailTemplate{}).Count(&total)
+	if totalRes.Error != nil {
+		return nil, totalRes.Error
+	}
+
+	paginationClone := pagination
+	paginationClone.Total = total
+
+	responseEmailTemplates := []*model.EmailTemplate{}
+	for _, w := range emailTemplates {
+		responseEmailTemplates = append(responseEmailTemplates, w.AsAPIEmailTemplate())
+	}
+	return &model.EmailTemplates{
+		Pagination:     &paginationClone,
+		EmailTemplates: responseEmailTemplates,
+	}, nil
+}
+
+// GetEmailTemplateByID to get EmailTemplate by id
+func (p *provider) GetEmailTemplateByID(ctx context.Context, emailTemplateID string) (*model.EmailTemplate, error) {
+	var emailTemplate models.EmailTemplate
+
+	result := p.db.Where("id = ?", emailTemplateID).First(&emailTemplate)
+	if result.Error != nil {
+		return nil, result.Error
+	}
+	return emailTemplate.AsAPIEmailTemplate(), nil
+}
+
+// GetEmailTemplateByEventName to get EmailTemplate by event_name
+func (p *provider) GetEmailTemplateByEventName(ctx context.Context, eventName string) (*model.EmailTemplate, error) {
+	var emailTemplate models.EmailTemplate
+
+	result := p.db.Where("event_name = ?", eventName).First(&emailTemplate)
+	if result.Error != nil {
+		return nil, result.Error
+	}
+	return emailTemplate.AsAPIEmailTemplate(), nil
+}
+
+// DeleteEmailTemplate to delete EmailTemplate
+func (p *provider) DeleteEmailTemplate(ctx context.Context, emailTemplate *model.EmailTemplate) error {
+	result := p.db.Delete(&models.EmailTemplate{
+		ID: emailTemplate.ID,
+	})
+	if result.Error != nil {
+		return result.Error
+	}
+
+	return nil
+}

server/db/providers/sql/env.go

@@ -1,6 +1,7 @@
 package sql
 
 import (
+	"context"
 	"time"
 
 	"github.com/authorizerdev/authorizer/server/db/models"
@@ -8,7 +9,7 @@ import (
 )
 
 // AddEnv to save environment information in database
-func (p *provider) AddEnv(env models.Env) (models.Env, error) {
+func (p *provider) AddEnv(ctx context.Context, env models.Env) (models.Env, error) {
 	if env.ID == "" {
 		env.ID = uuid.New().String()
 	}
@@ -25,7 +26,7 @@ func (p *provider) AddEnv(env models.Env) (models.Env, error) {
 }
 
 // UpdateEnv to update environment information in database
-func (p *provider) UpdateEnv(env models.Env) (models.Env, error) {
+func (p *provider) UpdateEnv(ctx context.Context, env models.Env) (models.Env, error) {
 	env.UpdatedAt = time.Now().Unix()
 	result := p.db.Save(&env)
 
@@ -36,7 +37,7 @@ func (p *provider) UpdateEnv(env models.Env) (models.Env, error) {
 }
 
 // GetEnv to get environment information from database
-func (p *provider) GetEnv() (models.Env, error) {
+func (p *provider) GetEnv(ctx context.Context) (models.Env, error) {
 	var env models.Env
 	result := p.db.First(&env)
 

server/db/providers/sql/provider.go

@@ -50,7 +50,7 @@ func NewProvider() (*provider, error) {
 		sqlDB, err = gorm.Open(postgres.Open(dbURL), ormConfig)
 	case constants.DbTypeSqlite:
 		sqlDB, err = gorm.Open(sqlite.Open(dbURL), ormConfig)
-	case constants.DbTypeMysql, constants.DbTypeMariaDB:
+	case constants.DbTypeMysql, constants.DbTypeMariaDB, constants.DbTypePlanetScaleDB:
 		sqlDB, err = gorm.Open(mysql.Open(dbURL), ormConfig)
 	case constants.DbTypeSqlserver:
 		sqlDB, err = gorm.Open(sqlserver.Open(dbURL), ormConfig)
@@ -60,7 +60,7 @@ func NewProvider() (*provider, error) {
 		return nil, err
 	}
 
-	err = sqlDB.AutoMigrate(&models.User{}, &models.VerificationRequest{}, &models.Session{}, &models.Env{})
+	err = sqlDB.AutoMigrate(&models.User{}, &models.VerificationRequest{}, &models.Session{}, &models.Env{}, &models.Webhook{}, models.WebhookLog{}, models.EmailTemplate{})
 	if err != nil {
 		return nil, err
 	}

server/db/providers/sql/session.go

@@ -1,6 +1,7 @@
 package sql
 
 import (
+	"context"
 	"time"
 
 	"github.com/authorizerdev/authorizer/server/db/models"
@@ -9,7 +10,7 @@ import (
 )
 
 // AddSession to save session information in database
-func (p *provider) AddSession(session models.Session) error {
+func (p *provider) AddSession(ctx context.Context, session models.Session) error {
 	if session.ID == "" {
 		session.ID = uuid.New().String()
 	}
@@ -26,13 +27,3 @@ func (p *provider) AddSession(session models.Session) error {
 	}
 	return nil
 }
-
-// DeleteSession to delete session information from database
-func (p *provider) DeleteSession(userId string) error {
-	result := p.db.Where("user_id = ?", userId).Delete(&models.Session{})
-
-	if result.Error != nil {
-		return result.Error
-	}
-	return nil
-}

server/db/providers/sql/user.go

@@ -1,6 +1,7 @@
 package sql
 
 import (
+	"context"
 	"time"
 
 	"github.com/authorizerdev/authorizer/server/constants"
@@ -12,7 +13,7 @@ import (
 )
 
 // AddUser to save user information in database
-func (p *provider) AddUser(user models.User) (models.User, error) {
+func (p *provider) AddUser(ctx context.Context, user models.User) (models.User, error) {
 	if user.ID == "" {
 		user.ID = uuid.New().String()
 	}
@@ -42,7 +43,7 @@ func (p *provider) AddUser(user models.User) (models.User, error) {
 }
 
 // UpdateUser to update user information in database
-func (p *provider) UpdateUser(user models.User) (models.User, error) {
+func (p *provider) UpdateUser(ctx context.Context, user models.User) (models.User, error) {
 	user.UpdatedAt = time.Now().Unix()
 
 	result := p.db.Save(&user)
@@ -55,18 +56,23 @@ func (p *provider) UpdateUser(user models.User) (models.User, error) {
 }
 
 // DeleteUser to delete user information from database
-func (p *provider) DeleteUser(user models.User) error {
+func (p *provider) DeleteUser(ctx context.Context, user models.User) error {
 	result := p.db.Delete(&user)
 
 	if result.Error != nil {
 		return result.Error
 	}
 
+	result = p.db.Where("user_id = ?", user.ID).Delete(&models.Session{})
+	if result.Error != nil {
+		return result.Error
+	}
+
 	return nil
 }
 
 // ListUsers to get list of users from database
-func (p *provider) ListUsers(pagination model.Pagination) (*model.Users, error) {
+func (p *provider) ListUsers(ctx context.Context, pagination model.Pagination) (*model.Users, error) {
 	var users []models.User
 	result := p.db.Limit(int(pagination.Limit)).Offset(int(pagination.Offset)).Order("created_at DESC").Find(&users)
 	if result.Error != nil {
@@ -94,7 +100,7 @@ func (p *provider) ListUsers(pagination model.Pagination) (*model.Users, error)
 }
 
 // GetUserByEmail to get user information from database using email address
-func (p *provider) GetUserByEmail(email string) (models.User, error) {
+func (p *provider) GetUserByEmail(ctx context.Context, email string) (models.User, error) {
 	var user models.User
 	result := p.db.Where("email = ?", email).First(&user)
 	if result.Error != nil {
@@ -105,7 +111,7 @@ func (p *provider) GetUserByEmail(email string) (models.User, error) {
 }
 
 // GetUserByID to get user information from database using user ID
-func (p *provider) GetUserByID(id string) (models.User, error) {
+func (p *provider) GetUserByID(ctx context.Context, id string) (models.User, error) {
 	var user models.User
 
 	result := p.db.Where("id = ?", id).First(&user)

server/db/providers/sql/verification_requests.go

@@ -1,6 +1,7 @@
 package sql
 
 import (
+	"context"
 	"time"
 
 	"github.com/authorizerdev/authorizer/server/db/models"
@@ -10,7 +11,7 @@ import (
 )
 
 // AddVerification to save verification request in database
-func (p *provider) AddVerificationRequest(verificationRequest models.VerificationRequest) (models.VerificationRequest, error) {
+func (p *provider) AddVerificationRequest(ctx context.Context, verificationRequest models.VerificationRequest) (models.VerificationRequest, error) {
 	if verificationRequest.ID == "" {
 		verificationRequest.ID = uuid.New().String()
 	}
@@ -31,7 +32,7 @@ func (p *provider) AddVerificationRequest(verificationRequest models.Verificatio
 }
 
 // GetVerificationRequestByToken to get verification request from database using token
-func (p *provider) GetVerificationRequestByToken(token string) (models.VerificationRequest, error) {
+func (p *provider) GetVerificationRequestByToken(ctx context.Context, token string) (models.VerificationRequest, error) {
 	var verificationRequest models.VerificationRequest
 	result := p.db.Where("token = ?", token).First(&verificationRequest)
 
@@ -43,7 +44,7 @@ func (p *provider) GetVerificationRequestByToken(token string) (models.Verificat
 }
 
 // GetVerificationRequestByEmail to get verification request by email from database
-func (p *provider) GetVerificationRequestByEmail(email string, identifier string) (models.VerificationRequest, error) {
+func (p *provider) GetVerificationRequestByEmail(ctx context.Context, email string, identifier string) (models.VerificationRequest, error) {
 	var verificationRequest models.VerificationRequest
 
 	result := p.db.Where("email = ? AND identifier = ?", email, identifier).First(&verificationRequest)
@@ -56,7 +57,7 @@ func (p *provider) GetVerificationRequestByEmail(email string, identifier string
 }
 
 // ListVerificationRequests to get list of verification requests from database
-func (p *provider) ListVerificationRequests(pagination model.Pagination) (*model.VerificationRequests, error) {
+func (p *provider) ListVerificationRequests(ctx context.Context, pagination model.Pagination) (*model.VerificationRequests, error) {
 	var verificationRequests []models.VerificationRequest
 
 	result := p.db.Limit(int(pagination.Limit)).Offset(int(pagination.Offset)).Order("created_at DESC").Find(&verificationRequests)
@@ -85,7 +86,7 @@ func (p *provider) ListVerificationRequests(pagination model.Pagination) (*model
 }
 
 // DeleteVerificationRequest to delete verification request from database
-func (p *provider) DeleteVerificationRequest(verificationRequest models.VerificationRequest) error {
+func (p *provider) DeleteVerificationRequest(ctx context.Context, verificationRequest models.VerificationRequest) error {
 	result := p.db.Delete(&verificationRequest)
 
 	if result.Error != nil {

server/db/providers/sql/webhook.go

@@ -0,0 +1,104 @@
+package sql
+
+import (
+	"context"
+	"time"
+
+	"github.com/authorizerdev/authorizer/server/db/models"
+	"github.com/authorizerdev/authorizer/server/graph/model"
+	"github.com/google/uuid"
+)
+
+// AddWebhook to add webhook
+func (p *provider) AddWebhook(ctx context.Context, webhook models.Webhook) (*model.Webhook, error) {
+	if webhook.ID == "" {
+		webhook.ID = uuid.New().String()
+	}
+
+	webhook.Key = webhook.ID
+	webhook.CreatedAt = time.Now().Unix()
+	webhook.UpdatedAt = time.Now().Unix()
+	res := p.db.Create(&webhook)
+	if res.Error != nil {
+		return nil, res.Error
+	}
+	return webhook.AsAPIWebhook(), nil
+}
+
+// UpdateWebhook to update webhook
+func (p *provider) UpdateWebhook(ctx context.Context, webhook models.Webhook) (*model.Webhook, error) {
+	webhook.UpdatedAt = time.Now().Unix()
+
+	result := p.db.Save(&webhook)
+	if result.Error != nil {
+		return nil, result.Error
+	}
+
+	return webhook.AsAPIWebhook(), nil
+}
+
+// ListWebhooks to list webhook
+func (p *provider) ListWebhook(ctx context.Context, pagination model.Pagination) (*model.Webhooks, error) {
+	var webhooks []models.Webhook
+
+	result := p.db.Limit(int(pagination.Limit)).Offset(int(pagination.Offset)).Order("created_at DESC").Find(&webhooks)
+	if result.Error != nil {
+		return nil, result.Error
+	}
+
+	var total int64
+	totalRes := p.db.Model(&models.Webhook{}).Count(&total)
+	if totalRes.Error != nil {
+		return nil, totalRes.Error
+	}
+
+	paginationClone := pagination
+	paginationClone.Total = total
+
+	responseWebhooks := []*model.Webhook{}
+	for _, w := range webhooks {
+		responseWebhooks = append(responseWebhooks, w.AsAPIWebhook())
+	}
+	return &model.Webhooks{
+		Pagination: &paginationClone,
+		Webhooks:   responseWebhooks,
+	}, nil
+}
+
+// GetWebhookByID to get webhook by id
+func (p *provider) GetWebhookByID(ctx context.Context, webhookID string) (*model.Webhook, error) {
+	var webhook models.Webhook
+
+	result := p.db.Where("id = ?", webhookID).First(&webhook)
+	if result.Error != nil {
+		return nil, result.Error
+	}
+	return webhook.AsAPIWebhook(), nil
+}
+
+// GetWebhookByEventName to get webhook by event_name
+func (p *provider) GetWebhookByEventName(ctx context.Context, eventName string) (*model.Webhook, error) {
+	var webhook models.Webhook
+
+	result := p.db.Where("event_name = ?", eventName).First(&webhook)
+	if result.Error != nil {
+		return nil, result.Error
+	}
+	return webhook.AsAPIWebhook(), nil
+}
+
+// DeleteWebhook to delete webhook
+func (p *provider) DeleteWebhook(ctx context.Context, webhook *model.Webhook) error {
+	result := p.db.Delete(&models.Webhook{
+		ID: webhook.ID,
+	})
+	if result.Error != nil {
+		return result.Error
+	}
+
+	result = p.db.Where("webhook_id = ?", webhook.ID).Delete(&models.WebhookLog{})
+	if result.Error != nil {
+		return result.Error
+	}
+	return nil
+}

server/db/providers/sql/webhook_log.go

@@ -0,0 +1,68 @@
+package sql
+
+import (
+	"context"
+	"time"
+
+	"github.com/authorizerdev/authorizer/server/db/models"
+	"github.com/authorizerdev/authorizer/server/graph/model"
+	"github.com/google/uuid"
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+)
+
+// AddWebhookLog to add webhook log
+func (p *provider) AddWebhookLog(ctx context.Context, webhookLog models.WebhookLog) (*model.WebhookLog, error) {
+	if webhookLog.ID == "" {
+		webhookLog.ID = uuid.New().String()
+	}
+
+	webhookLog.Key = webhookLog.ID
+	webhookLog.CreatedAt = time.Now().Unix()
+	webhookLog.UpdatedAt = time.Now().Unix()
+	res := p.db.Clauses(
+		clause.OnConflict{
+			DoNothing: true,
+		}).Create(&webhookLog)
+	if res.Error != nil {
+		return nil, res.Error
+	}
+
+	return webhookLog.AsAPIWebhookLog(), nil
+}
+
+// ListWebhookLogs to list webhook logs
+func (p *provider) ListWebhookLogs(ctx context.Context, pagination model.Pagination, webhookID string) (*model.WebhookLogs, error) {
+	var webhookLogs []models.WebhookLog
+	var result *gorm.DB
+	var totalRes *gorm.DB
+	var total int64
+
+	if webhookID != "" {
+		result = p.db.Where("webhook_id = ?", webhookID).Limit(int(pagination.Limit)).Offset(int(pagination.Offset)).Order("created_at DESC").Find(&webhookLogs)
+		totalRes = p.db.Where("webhook_id = ?", webhookID).Model(&models.WebhookLog{}).Count(&total)
+	} else {
+		result = p.db.Limit(int(pagination.Limit)).Offset(int(pagination.Offset)).Order("created_at DESC").Find(&webhookLogs)
+		totalRes = p.db.Model(&models.WebhookLog{}).Count(&total)
+	}
+
+	if result.Error != nil {
+		return nil, result.Error
+	}
+
+	if totalRes.Error != nil {
+		return nil, totalRes.Error
+	}
+
+	paginationClone := pagination
+	paginationClone.Total = total
+
+	responseWebhookLogs := []*model.WebhookLog{}
+	for _, w := range webhookLogs {
+		responseWebhookLogs = append(responseWebhookLogs, w.AsAPIWebhookLog())
+	}
+	return &model.WebhookLogs{
+		WebhookLogs: responseWebhookLogs,
+		Pagination:  &paginationClone,
+	}, nil
+}

server/email/invite_email.go

@@ -70,7 +70,7 @@ func InviteEmail(toEmail, token, verificationURL, redirectURI string) error {
                                                                                         <tr style="background: rgb(249,250,251);padding: 10px;margin-bottom:10px;border-radius:5px;">
                                                                                             <td class="esd-block-text es-m-txt-c es-p15t" align="center" style="padding:10px;padding-bottom:30px;">
                                                                                                 <p>Hi there 👋</p>
-                                                                                                <p>Join us! You are invited to sign-up for <b>{{.org_name}}</b>. Please accept the invitation by clicking the clicking the button below.</p> <br/>
+                                                                                                <p>Join us! You are invited to sign-up for <b>{{.org_name}}</b>. Please accept the invitation by clicking the button below.</p> <br/>
                                                                                                 <a 
                                                                                                 clicktracking="off" href="{{.verification_url}}" class="es-button" target="_blank" style="text-decoration: none;padding:10px 15px;background-color: rgba(59,130,246,1);color: #fff;font-size: 1em;border-radius:5px;">Get Started</a>
                                                                                             </td>

server/env/env.go

@@ -83,6 +83,7 @@ func InitAllEnv() error {
 	osDisableLoginPage := os.Getenv(constants.EnvKeyDisableLoginPage)
 	osDisableSignUp := os.Getenv(constants.EnvKeyDisableSignUp)
 	osDisableRedisForEnv := os.Getenv(constants.EnvKeyDisableRedisForEnv)
+	osDisableStrongPassword := os.Getenv(constants.EnvKeyDisableStrongPassword)
 
 	// os slice vars
 	osAllowedOrigins := os.Getenv(constants.EnvKeyAllowedOrigins)
@@ -476,6 +477,19 @@ func InitAllEnv() error {
 		}
 	}
 
+	if _, ok := envData[constants.EnvKeyDisableStrongPassword]; !ok {
+		envData[constants.EnvKeyDisableStrongPassword] = osDisableStrongPassword == "true"
+	}
+	if osDisableStrongPassword != "" {
+		boolValue, err := strconv.ParseBool(osDisableStrongPassword)
+		if err != nil {
+			return err
+		}
+		if boolValue != envData[constants.EnvKeyDisableStrongPassword].(bool) {
+			envData[constants.EnvKeyDisableStrongPassword] = boolValue
+		}
+	}
+
 	// no need to add nil check as its already done above
 	if envData[constants.EnvKeySmtpHost] == "" || envData[constants.EnvKeySmtpUsername] == "" || envData[constants.EnvKeySmtpPassword] == "" || envData[constants.EnvKeySenderEmail] == "" && envData[constants.EnvKeySmtpPort] == "" {
 		envData[constants.EnvKeyDisableEmailVerification] = true

server/env/persist_env.go

@@ -1,6 +1,7 @@
 package env
 
 import (
+	"context"
 	"encoding/json"
 	"os"
 	"reflect"
@@ -58,7 +59,8 @@ func fixBackwardCompatibility(data map[string]interface{}) (bool, map[string]int
 // GetEnvData returns the env data from database
 func GetEnvData() (map[string]interface{}, error) {
 	var result map[string]interface{}
-	env, err := db.Provider.GetEnv()
+	ctx := context.Background()
+	env, err := db.Provider.GetEnv(ctx)
 	// config not found in db
 	if err != nil {
 		log.Debug("Error while getting env data from db: ", err)
@@ -108,9 +110,10 @@ func GetEnvData() (map[string]interface{}, error) {
 
 // PersistEnv persists the environment variables to the database
 func PersistEnv() error {
-	env, err := db.Provider.GetEnv()
+	ctx := context.Background()
+	env, err := db.Provider.GetEnv(ctx)
 	// config not found in db
-	if err != nil {
+	if err != nil || env.EnvData == "" {
 		// AES encryption needs 32 bit key only, so we chop off last 4 characters from 36 bit uuid
 		hash := uuid.New().String()[:36-4]
 		err := memorystore.Provider.UpdateEnvVariable(constants.EnvKeyEncryptionKey, hash)
@@ -137,7 +140,7 @@ func PersistEnv() error {
 			EnvData: encryptedConfig,
 		}
 
-		env, err = db.Provider.AddEnv(env)
+		env, err = db.Provider.AddEnv(ctx, env)
 		if err != nil {
 			log.Debug("Error while persisting env data to db: ", err)
 			return err
@@ -171,7 +174,7 @@ func PersistEnv() error {
 
 		err = json.Unmarshal(decryptedConfigs, &storeData)
 		if err != nil {
-			log.Debug("Error while unmarshalling env data: ", err)
+			log.Debug("Error while un-marshalling env data: ", err)
 			return err
 		}
 
@@ -198,7 +201,7 @@ func PersistEnv() error {
 				envValue := strings.TrimSpace(os.Getenv(key))
 				if envValue != "" {
 					switch key {
-					case constants.EnvKeyIsProd, constants.EnvKeyDisableBasicAuthentication, constants.EnvKeyDisableEmailVerification, constants.EnvKeyDisableLoginPage, constants.EnvKeyDisableMagicLinkLogin, constants.EnvKeyDisableSignUp, constants.EnvKeyDisableRedisForEnv:
+					case constants.EnvKeyIsProd, constants.EnvKeyDisableBasicAuthentication, constants.EnvKeyDisableEmailVerification, constants.EnvKeyDisableLoginPage, constants.EnvKeyDisableMagicLinkLogin, constants.EnvKeyDisableSignUp, constants.EnvKeyDisableRedisForEnv, constants.EnvKeyDisableStrongPassword:
 						if envValueBool, err := strconv.ParseBool(envValue); err == nil {
 							if value.(bool) != envValueBool {
 								storeData[key] = envValueBool
@@ -251,7 +254,7 @@ func PersistEnv() error {
 			}
 
 			env.EnvData = encryptedConfig
-			_, err = db.Provider.UpdateEnv(env)
+			_, err = db.Provider.UpdateEnv(ctx, env)
 			if err != nil {
 				log.Debug("Failed to Update Config: ", err)
 				return err

server/graph/model/models_gen.go

@@ -2,6 +2,18 @@
 
 package model
 
+type AddEmailTemplateRequest struct {
+	EventName string `json:"event_name"`
+	Template  string `json:"template"`
+}
+
+type AddWebhookRequest struct {
+	EventName string                 `json:"event_name"`
+	Endpoint  string                 `json:"endpoint"`
+	Enabled   bool                   `json:"enabled"`
+	Headers   map[string]interface{} `json:"headers"`
+}
+
 type AdminLoginInput struct {
 	AdminSecret string `json:"admin_secret"`
 }
@@ -19,10 +31,27 @@ type AuthResponse struct {
 	User         *User   `json:"user"`
 }
 
+type DeleteEmailTemplateRequest struct {
+	ID string `json:"id"`
+}
+
 type DeleteUserInput struct {
 	Email string `json:"email"`
 }
 
+type EmailTemplate struct {
+	ID        string `json:"id"`
+	EventName string `json:"event_name"`
+	Template  string `json:"template"`
+	CreatedAt *int64 `json:"created_at"`
+	UpdatedAt *int64 `json:"updated_at"`
+}
+
+type EmailTemplates struct {
+	Pagination     *Pagination      `json:"pagination"`
+	EmailTemplates []*EmailTemplate `json:"EmailTemplates"`
+}
+
 type Env struct {
 	AccessTokenExpiryTime      *string  `json:"ACCESS_TOKEN_EXPIRY_TIME"`
 	AdminSecret                *string  `json:"ADMIN_SECRET"`
@@ -55,6 +84,7 @@ type Env struct {
 	DisableLoginPage           bool     `json:"DISABLE_LOGIN_PAGE"`
 	DisableSignUp              bool     `json:"DISABLE_SIGN_UP"`
 	DisableRedisForEnv         bool     `json:"DISABLE_REDIS_FOR_ENV"`
+	DisableStrongPassword      bool     `json:"DISABLE_STRONG_PASSWORD"`
 	Roles                      []string `json:"ROLES"`
 	ProtectedRoles             []string `json:"PROTECTED_ROLES"`
 	DefaultRoles               []string `json:"DEFAULT_ROLES"`
@@ -99,6 +129,11 @@ type InviteMemberInput struct {
 	RedirectURI *string  `json:"redirect_uri"`
 }
 
+type ListWebhookLogRequest struct {
+	Pagination *PaginationInput `json:"pagination"`
+	WebhookID  *string          `json:"webhook_id"`
+}
+
 type LoginInput struct {
 	Email    string   `json:"email"`
 	Password string   `json:"password"`
@@ -126,6 +161,7 @@ type Meta struct {
 	IsBasicAuthenticationEnabled bool   `json:"is_basic_authentication_enabled"`
 	IsMagicLinkLoginEnabled      bool   `json:"is_magic_link_login_enabled"`
 	IsSignUpEnabled              bool   `json:"is_sign_up_enabled"`
+	IsStrongPasswordEnabled      bool   `json:"is_strong_password_enabled"`
 }
 
 type OAuthRevokeInput struct {
@@ -185,10 +221,27 @@ type SignUpInput struct {
 	RedirectURI     *string  `json:"redirect_uri"`
 }
 
+type TestEndpointRequest struct {
+	Endpoint  string                 `json:"endpoint"`
+	EventName string                 `json:"event_name"`
+	Headers   map[string]interface{} `json:"headers"`
+}
+
+type TestEndpointResponse struct {
+	HTTPStatus *int64                 `json:"http_status"`
+	Response   map[string]interface{} `json:"response"`
+}
+
 type UpdateAccessInput struct {
 	UserID string `json:"user_id"`
 }
 
+type UpdateEmailTemplateRequest struct {
+	ID        string  `json:"id"`
+	EventName *string `json:"event_name"`
+	Template  *string `json:"template"`
+}
+
 type UpdateEnvInput struct {
 	AccessTokenExpiryTime      *string  `json:"ACCESS_TOKEN_EXPIRY_TIME"`
 	AdminSecret                *string  `json:"ADMIN_SECRET"`
@@ -212,6 +265,7 @@ type UpdateEnvInput struct {
 	DisableLoginPage           *bool    `json:"DISABLE_LOGIN_PAGE"`
 	DisableSignUp              *bool    `json:"DISABLE_SIGN_UP"`
 	DisableRedisForEnv         *bool    `json:"DISABLE_REDIS_FOR_ENV"`
+	DisableStrongPassword      *bool    `json:"DISABLE_STRONG_PASSWORD"`
 	Roles                      []string `json:"ROLES"`
 	ProtectedRoles             []string `json:"PROTECTED_ROLES"`
 	DefaultRoles               []string `json:"DEFAULT_ROLES"`
@@ -260,6 +314,14 @@ type UpdateUserInput struct {
 	Roles         []*string `json:"roles"`
 }
 
+type UpdateWebhookRequest struct {
+	ID        string                 `json:"id"`
+	EventName *string                `json:"event_name"`
+	Endpoint  *string                `json:"endpoint"`
+	Enabled   *bool                  `json:"enabled"`
+	Headers   map[string]interface{} `json:"headers"`
+}
+
 type User struct {
 	ID                  string   `json:"id"`
 	Email               string   `json:"email"`
@@ -316,3 +378,37 @@ type VerificationRequests struct {
 type VerifyEmailInput struct {
 	Token string `json:"token"`
 }
+
+type Webhook struct {
+	ID        string                 `json:"id"`
+	EventName *string                `json:"event_name"`
+	Endpoint  *string                `json:"endpoint"`
+	Enabled   *bool                  `json:"enabled"`
+	Headers   map[string]interface{} `json:"headers"`
+	CreatedAt *int64                 `json:"created_at"`
+	UpdatedAt *int64                 `json:"updated_at"`
+}
+
+type WebhookLog struct {
+	ID         string  `json:"id"`
+	HTTPStatus *int64  `json:"http_status"`
+	Response   *string `json:"response"`
+	Request    *string `json:"request"`
+	WebhookID  *string `json:"webhook_id"`
+	CreatedAt  *int64  `json:"created_at"`
+	UpdatedAt  *int64  `json:"updated_at"`
+}
+
+type WebhookLogs struct {
+	Pagination  *Pagination   `json:"pagination"`
+	WebhookLogs []*WebhookLog `json:"webhook_logs"`
+}
+
+type WebhookRequest struct {
+	ID string `json:"id"`
+}
+
+type Webhooks struct {
+	Pagination *Pagination `json:"pagination"`
+	Webhooks   []*Webhook  `json:"webhooks"`
+}

server/graph/schema.graphqls

@@ -24,6 +24,7 @@ type Meta {
 	is_basic_authentication_enabled: Boolean!
 	is_magic_link_login_enabled: Boolean!
 	is_sign_up_enabled: Boolean!
+	is_strong_password_enabled: Boolean!
 }
 
 type User {
@@ -120,6 +121,7 @@ type Env {
 	DISABLE_LOGIN_PAGE: Boolean!
 	DISABLE_SIGN_UP: Boolean!
 	DISABLE_REDIS_FOR_ENV: Boolean!
+	DISABLE_STRONG_PASSWORD: Boolean!
 	ROLES: [String!]
 	PROTECTED_ROLES: [String!]
 	DEFAULT_ROLES: [String!]
@@ -148,6 +150,54 @@ type GenerateJWTKeysResponse {
 	private_key: String
 }
 
+type Webhook {
+	id: ID!
+	event_name: String
+	endpoint: String
+	enabled: Boolean
+	headers: Map
+	created_at: Int64
+	updated_at: Int64
+}
+
+type Webhooks {
+	pagination: Pagination!
+	webhooks: [Webhook!]!
+}
+
+type WebhookLog {
+	id: ID!
+	http_status: Int64
+	response: String
+	request: String
+	webhook_id: ID
+	created_at: Int64
+	updated_at: Int64
+}
+
+type TestEndpointResponse {
+	http_status: Int64
+	response: Map
+}
+
+type WebhookLogs {
+	pagination: Pagination!
+	webhook_logs: [WebhookLog!]!
+}
+
+type EmailTemplate {
+	id: ID!
+	event_name: String!
+	template: String!
+	created_at: Int64
+	updated_at: Int64
+}
+
+type EmailTemplates {
+	pagination: Pagination!
+	EmailTemplates: [EmailTemplate!]!
+}
+
 input UpdateEnvInput {
 	ACCESS_TOKEN_EXPIRY_TIME: String
 	ADMIN_SECRET: String
@@ -171,6 +221,7 @@ input UpdateEnvInput {
 	DISABLE_LOGIN_PAGE: Boolean
 	DISABLE_SIGN_UP: Boolean
 	DISABLE_REDIS_FOR_ENV: Boolean
+	DISABLE_STRONG_PASSWORD: Boolean
 	ROLES: [String!]
 	PROTECTED_ROLES: [String!]
 	DEFAULT_ROLES: [String!]
@@ -321,6 +372,51 @@ input GenerateJWTKeysInput {
 	type: String!
 }
 
+input ListWebhookLogRequest {
+	pagination: PaginationInput
+	webhook_id: String
+}
+
+input AddWebhookRequest {
+	event_name: String!
+	endpoint: String!
+	enabled: Boolean!
+	headers: Map
+}
+
+input UpdateWebhookRequest {
+	id: ID!
+	event_name: String
+	endpoint: String
+	enabled: Boolean
+	headers: Map
+}
+
+input WebhookRequest {
+	id: ID!
+}
+
+input TestEndpointRequest {
+	endpoint: String!
+	event_name: String!
+	headers: Map
+}
+
+input AddEmailTemplateRequest {
+	event_name: String!
+	template: String!
+}
+
+input UpdateEmailTemplateRequest {
+	id: ID!
+	event_name: String
+	template: String
+}
+
+input DeleteEmailTemplateRequest {
+	id: ID!
+}
+
 type Mutation {
 	signup(params: SignUpInput!): AuthResponse!
 	login(params: LoginInput!): AuthResponse!
@@ -343,6 +439,13 @@ type Mutation {
 	_revoke_access(param: UpdateAccessInput!): Response!
 	_enable_access(param: UpdateAccessInput!): Response!
 	_generate_jwt_keys(params: GenerateJWTKeysInput!): GenerateJWTKeysResponse!
+	_add_webhook(params: AddWebhookRequest!): Response!
+	_update_webhook(params: UpdateWebhookRequest!): Response!
+	_delete_webhook(params: WebhookRequest!): Response!
+	_test_endpoint(params: TestEndpointRequest!): TestEndpointResponse!
+	_add_email_template(params: AddEmailTemplateRequest!): Response!
+	_update_email_template(params: UpdateEmailTemplateRequest!): Response!
+	_delete_email_template(params: DeleteEmailTemplateRequest!): Response!
 }
 
 type Query {
@@ -355,4 +458,8 @@ type Query {
 	_verification_requests(params: PaginatedInput): VerificationRequests!
 	_admin_session: Response!
 	_env: Env!
+	_webhook(params: WebhookRequest!): Webhook!
+	_webhooks(params: PaginatedInput): Webhooks!
+	_webhook_logs(params: ListWebhookLogRequest): WebhookLogs!
+	_email_templates(params: PaginatedInput): EmailTemplates!
 }

server/graph/schema.resolvers.go

@@ -91,6 +91,34 @@ func (r *mutationResolver) GenerateJwtKeys(ctx context.Context, params model.Gen
 	return resolvers.GenerateJWTKeysResolver(ctx, params)
 }
 
+func (r *mutationResolver) AddWebhook(ctx context.Context, params model.AddWebhookRequest) (*model.Response, error) {
+	return resolvers.AddWebhookResolver(ctx, params)
+}
+
+func (r *mutationResolver) UpdateWebhook(ctx context.Context, params model.UpdateWebhookRequest) (*model.Response, error) {
+	return resolvers.UpdateWebhookResolver(ctx, params)
+}
+
+func (r *mutationResolver) DeleteWebhook(ctx context.Context, params model.WebhookRequest) (*model.Response, error) {
+	return resolvers.DeleteWebhookResolver(ctx, params)
+}
+
+func (r *mutationResolver) TestEndpoint(ctx context.Context, params model.TestEndpointRequest) (*model.TestEndpointResponse, error) {
+	return resolvers.TestEndpointResolver(ctx, params)
+}
+
+func (r *mutationResolver) AddEmailTemplate(ctx context.Context, params model.AddEmailTemplateRequest) (*model.Response, error) {
+	return resolvers.AddEmailTemplateResolver(ctx, params)
+}
+
+func (r *mutationResolver) UpdateEmailTemplate(ctx context.Context, params model.UpdateEmailTemplateRequest) (*model.Response, error) {
+	return resolvers.UpdateEmailTemplateResolver(ctx, params)
+}
+
+func (r *mutationResolver) DeleteEmailTemplate(ctx context.Context, params model.DeleteEmailTemplateRequest) (*model.Response, error) {
+	return resolvers.DeleteEmailTemplateResolver(ctx, params)
+}
+
 func (r *queryResolver) Meta(ctx context.Context) (*model.Meta, error) {
 	return resolvers.MetaResolver(ctx)
 }
@@ -123,11 +151,29 @@ func (r *queryResolver) Env(ctx context.Context) (*model.Env, error) {
 	return resolvers.EnvResolver(ctx)
 }
 
+func (r *queryResolver) Webhook(ctx context.Context, params model.WebhookRequest) (*model.Webhook, error) {
+	return resolvers.WebhookResolver(ctx, params)
+}
+
+func (r *queryResolver) Webhooks(ctx context.Context, params *model.PaginatedInput) (*model.Webhooks, error) {
+	return resolvers.WebhooksResolver(ctx, params)
+}
+
+func (r *queryResolver) WebhookLogs(ctx context.Context, params *model.ListWebhookLogRequest) (*model.WebhookLogs, error) {
+	return resolvers.WebhookLogsResolver(ctx, params)
+}
+
+func (r *queryResolver) EmailTemplates(ctx context.Context, params *model.PaginatedInput) (*model.EmailTemplates, error) {
+	return resolvers.EmailTemplatesResolver(ctx, params)
+}
+
 // Mutation returns generated.MutationResolver implementation.
 func (r *Resolver) Mutation() generated.MutationResolver { return &mutationResolver{r} }
 
 // Query returns generated.QueryResolver implementation.
 func (r *Resolver) Query() generated.QueryResolver { return &queryResolver{r} }
 
-type mutationResolver struct{ *Resolver }
+type (
-type queryResolver struct{ *Resolver }
+	mutationResolver struct{ *Resolver }
+	queryResolver    struct{ *Resolver }
+)

server/handlers/authorize.go

@@ -199,7 +199,7 @@ func AuthorizeHandler() gin.HandlerFunc {
 			return
 		}
 		userID := claims.Subject
-		user, err := db.Provider.GetUserByID(userID)
+		user, err := db.Provider.GetUserByID(gc, userID)
 		if err != nil {
 			if isQuery {
 				gc.Redirect(http.StatusFound, loginURL)
@@ -218,13 +218,18 @@ func AuthorizeHandler() gin.HandlerFunc {
 			return
 		}
 
+		sessionKey := user.ID
+		if claims.LoginMethod != "" {
+			sessionKey = claims.LoginMethod + ":" + user.ID
+		}
+
 		// if user is logged in
-		// based on the response type, generate the response
+		// based on the response type code, generate the response
 		if isResponseTypeCode {
 			// rollover the session for security
-			go memorystore.Provider.DeleteUserSession(user.ID, claims.Nonce)
+			go memorystore.Provider.DeleteUserSession(sessionKey, claims.Nonce)
 			nonce := uuid.New().String()
-			newSessionTokenData, newSessionToken, err := token.CreateSessionToken(user, nonce, claims.Roles, scope)
+			newSessionTokenData, newSessionToken, err := token.CreateSessionToken(user, nonce, claims.Roles, scope, claims.LoginMethod)
 			if err != nil {
 				if isQuery {
 					gc.Redirect(http.StatusFound, loginURL)
@@ -262,7 +267,7 @@ func AuthorizeHandler() gin.HandlerFunc {
 
 		if isResponseTypeToken {
 			// rollover the session for security
-			authToken, err := token.CreateAuthToken(gc, user, claims.Roles, scope)
+			authToken, err := token.CreateAuthToken(gc, user, claims.Roles, scope, claims.LoginMethod)
 			if err != nil {
 				if isQuery {
 					gc.Redirect(http.StatusFound, loginURL)
@@ -280,9 +285,10 @@ func AuthorizeHandler() gin.HandlerFunc {
 				}
 				return
 			}
-			go memorystore.Provider.DeleteUserSession(user.ID, claims.Nonce)
+
-			memorystore.Provider.SetUserSession(user.ID, constants.TokenTypeSessionToken+"_"+authToken.FingerPrint, authToken.FingerPrintHash)
+			go memorystore.Provider.DeleteUserSession(sessionKey, claims.Nonce)
-			memorystore.Provider.SetUserSession(user.ID, constants.TokenTypeAccessToken+"_"+authToken.FingerPrint, authToken.AccessToken.Token)
+			memorystore.Provider.SetUserSession(sessionKey, constants.TokenTypeSessionToken+"_"+authToken.FingerPrint, authToken.FingerPrintHash)
+			memorystore.Provider.SetUserSession(sessionKey, constants.TokenTypeAccessToken+"_"+authToken.FingerPrint, authToken.AccessToken.Token)
 			cookie.SetSession(gc, authToken.FingerPrintHash)
 
 			expiresIn := authToken.AccessToken.ExpiresAt - time.Now().Unix()
@@ -305,7 +311,7 @@ func AuthorizeHandler() gin.HandlerFunc {
 			if authToken.RefreshToken != nil {
 				res["refresh_token"] = authToken.RefreshToken.Token
 				params += "&refresh_token=" + authToken.RefreshToken.Token
-				memorystore.Provider.SetUserSession(user.ID, constants.TokenTypeRefreshToken+"_"+authToken.FingerPrint, authToken.RefreshToken.Token)
+				memorystore.Provider.SetUserSession(sessionKey, constants.TokenTypeRefreshToken+"_"+authToken.FingerPrint, authToken.RefreshToken.Token)
 			}
 
 			if isQuery {

server/handlers/oauth_callback.go

@@ -2,6 +2,7 @@ package handlers
 
 import (
 	"context"
+	"encoding/base64"
 	"encoding/json"
 	"fmt"
 	"io/ioutil"
@@ -17,7 +18,6 @@ import (
 
 	"github.com/authorizerdev/authorizer/server/constants"
 	"github.com/authorizerdev/authorizer/server/cookie"
-	"github.com/authorizerdev/authorizer/server/crypto"
 	"github.com/authorizerdev/authorizer/server/db"
 	"github.com/authorizerdev/authorizer/server/db/models"
 	"github.com/authorizerdev/authorizer/server/memorystore"
@@ -28,21 +28,21 @@ import (
 
 // OAuthCallbackHandler handles the OAuth callback for various oauth providers
 func OAuthCallbackHandler() gin.HandlerFunc {
-	return func(c *gin.Context) {
+	return func(ctx *gin.Context) {
-		provider := c.Param("oauth_provider")
+		provider := ctx.Param("oauth_provider")
-		state := c.Request.FormValue("state")
+		state := ctx.Request.FormValue("state")
 
 		sessionState, err := memorystore.Provider.GetState(state)
 		if sessionState == "" || err != nil {
 			log.Debug("Invalid oauth state: ", state)
-			c.JSON(400, gin.H{"error": "invalid oauth state"})
+			ctx.JSON(400, gin.H{"error": "invalid oauth state"})
 		}
 		// contains random token, redirect url, role
 		sessionSplit := strings.Split(state, "___")
 
 		if len(sessionSplit) < 3 {
 			log.Debug("Unable to get redirect url from state: ", state)
-			c.JSON(400, gin.H{"error": "invalid redirect url"})
+			ctx.JSON(400, gin.H{"error": "invalid redirect url"})
 			return
 		}
 
@@ -55,17 +55,17 @@ func OAuthCallbackHandler() gin.HandlerFunc {
 		scopes := strings.Split(sessionSplit[3], ",")
 
 		user := models.User{}
-		code := c.Request.FormValue("code")
+		code := ctx.Request.FormValue("code")
 		switch provider {
-		case constants.SignupMethodGoogle:
+		case constants.AuthRecipeMethodGoogle:
 			user, err = processGoogleUserInfo(code)
-		case constants.SignupMethodGithub:
+		case constants.AuthRecipeMethodGithub:
 			user, err = processGithubUserInfo(code)
-		case constants.SignupMethodFacebook:
+		case constants.AuthRecipeMethodFacebook:
 			user, err = processFacebookUserInfo(code)
-		case constants.SignupMethodLinkedIn:
+		case constants.AuthRecipeMethodLinkedIn:
 			user, err = processLinkedInUserInfo(code)
-		case constants.SignupMethodApple:
+		case constants.AuthRecipeMethodApple:
 			user, err = processAppleUserInfo(code)
 		default:
 			log.Info("Invalid oauth provider")
@@ -74,23 +74,24 @@ func OAuthCallbackHandler() gin.HandlerFunc {
 
 		if err != nil {
 			log.Debug("Failed to process user info: ", err)
-			c.JSON(400, gin.H{"error": err.Error()})
+			ctx.JSON(400, gin.H{"error": err.Error()})
 			return
 		}
 
-		existingUser, err := db.Provider.GetUserByEmail(user.Email)
+		existingUser, err := db.Provider.GetUserByEmail(ctx, user.Email)
 		log := log.WithField("user", user.Email)
+		isSignUp := false
 
 		if err != nil {
 			isSignupDisabled, err := memorystore.Provider.GetBoolStoreEnvVariable(constants.EnvKeyDisableSignUp)
 			if err != nil {
 				log.Debug("Failed to get signup disabled env variable: ", err)
-				c.JSON(400, gin.H{"error": err.Error()})
+				ctx.JSON(400, gin.H{"error": err.Error()})
 				return
 			}
 			if isSignupDisabled {
 				log.Debug("Failed to signup as disabled")
-				c.JSON(400, gin.H{"error": "signup is disabled for this instance"})
+				ctx.JSON(400, gin.H{"error": "signup is disabled for this instance"})
 				return
 			}
 			// user not registered, register user and generate session token
@@ -113,19 +114,20 @@ func OAuthCallbackHandler() gin.HandlerFunc {
 
 			if hasProtectedRole {
 				log.Debug("Signup is not allowed with protected roles:", inputRoles)
-				c.JSON(400, gin.H{"error": "invalid role"})
+				ctx.JSON(400, gin.H{"error": "invalid role"})
 				return
 			}
 
 			user.Roles = strings.Join(inputRoles, ",")
 			now := time.Now().Unix()
 			user.EmailVerifiedAt = &now
-			user, _ = db.Provider.AddUser(user)
+			user, _ = db.Provider.AddUser(ctx, user)
+			isSignUp = true
 		} else {
 			user = existingUser
 			if user.RevokedTimestamp != nil {
 				log.Debug("User access revoked at: ", user.RevokedTimestamp)
-				c.JSON(400, gin.H{"error": "user access has been revoked"})
+				ctx.JSON(400, gin.H{"error": "user access has been revoked"})
 				return
 			}
 
@@ -175,7 +177,7 @@ func OAuthCallbackHandler() gin.HandlerFunc {
 
 				if hasProtectedRole {
 					log.Debug("Invalid role. User is using protected unassigned role")
-					c.JSON(400, gin.H{"error": "invalid role"})
+					ctx.JSON(400, gin.H{"error": "invalid role"})
 					return
 				} else {
 					user.Roles = existingUser.Roles + "," + strings.Join(unasignedRoles, ",")
@@ -184,18 +186,18 @@ func OAuthCallbackHandler() gin.HandlerFunc {
 				user.Roles = existingUser.Roles
 			}
 
-			user, err = db.Provider.UpdateUser(user)
+			user, err = db.Provider.UpdateUser(ctx, user)
 			if err != nil {
 				log.Debug("Failed to update user: ", err)
-				c.JSON(500, gin.H{"error": err.Error()})
+				ctx.JSON(500, gin.H{"error": err.Error()})
 				return
 			}
 		}
 
-		authToken, err := token.CreateAuthToken(c, user, inputRoles, scopes)
+		authToken, err := token.CreateAuthToken(ctx, user, inputRoles, scopes, provider)
 		if err != nil {
 			log.Debug("Failed to create auth token: ", err)
-			c.JSON(500, gin.H{"error": err.Error()})
+			ctx.JSON(500, gin.H{"error": err.Error()})
 		}
 
 		expiresIn := authToken.AccessToken.ExpiresAt - time.Now().Unix()
@@ -205,27 +207,35 @@ func OAuthCallbackHandler() gin.HandlerFunc {
 
 		params := "access_token=" + authToken.AccessToken.Token + "&token_type=bearer&expires_in=" + strconv.FormatInt(expiresIn, 10) + "&state=" + stateValue + "&id_token=" + authToken.IDToken.Token
 
-		cookie.SetSession(c, authToken.FingerPrintHash)
+		sessionKey := provider + ":" + user.ID
-		memorystore.Provider.SetUserSession(user.ID, constants.TokenTypeSessionToken+"_"+authToken.FingerPrint, authToken.FingerPrintHash)
+		cookie.SetSession(ctx, authToken.FingerPrintHash)
-		memorystore.Provider.SetUserSession(user.ID, constants.TokenTypeAccessToken+"_"+authToken.FingerPrint, authToken.AccessToken.Token)
+		memorystore.Provider.SetUserSession(sessionKey, constants.TokenTypeSessionToken+"_"+authToken.FingerPrint, authToken.FingerPrintHash)
+		memorystore.Provider.SetUserSession(sessionKey, constants.TokenTypeAccessToken+"_"+authToken.FingerPrint, authToken.AccessToken.Token)
 
 		if authToken.RefreshToken != nil {
 			params = params + `&refresh_token=` + authToken.RefreshToken.Token
-			memorystore.Provider.SetUserSession(user.ID, constants.TokenTypeRefreshToken+"_"+authToken.FingerPrint, authToken.RefreshToken.Token)
+			memorystore.Provider.SetUserSession(sessionKey, constants.TokenTypeRefreshToken+"_"+authToken.FingerPrint, authToken.RefreshToken.Token)
 		}
 
-		go db.Provider.AddSession(models.Session{
+		go func() {
-			UserID:    user.ID,
+			if isSignUp {
-			UserAgent: utils.GetUserAgent(c.Request),
+				utils.RegisterEvent(ctx, constants.UserSignUpWebhookEvent, provider, user)
-			IP:        utils.GetIP(c.Request),
+			} else {
-		})
+				utils.RegisterEvent(ctx, constants.UserLoginWebhookEvent, provider, user)
+			}
+			db.Provider.AddSession(ctx, models.Session{
+				UserID:    user.ID,
+				UserAgent: utils.GetUserAgent(ctx.Request),
+				IP:        utils.GetIP(ctx.Request),
+			})
+		}()
 		if strings.Contains(redirectURL, "?") {
 			redirectURL = redirectURL + "&" + params
 		} else {
 			redirectURL = redirectURL + "?" + strings.TrimPrefix(params, "&")
 		}
 
-		c.Redirect(http.StatusTemporaryRedirect, redirectURL)
+		ctx.Redirect(http.StatusFound, redirectURL)
 	}
 }
 
@@ -310,12 +320,60 @@ func processGithubUserInfo(code string) (models.User, error) {
 	}
 
 	picture := userRawData["avatar_url"]
+	email := userRawData["email"]
+
+	if email == "" {
+		type GithubUserEmails struct {
+			Email   string `json:"email"`
+			Primary bool   `json:"primary"`
+		}
+
+		// fetch using /users/email endpoint
+		req, err := http.NewRequest("GET", constants.GithubUserEmails, nil)
+		if err != nil {
+			log.Debug("Failed to create github emails request: ", err)
+			return user, fmt.Errorf("error creating github user info request: %s", err.Error())
+		}
+		req.Header = http.Header{
+			"Authorization": []string{fmt.Sprintf("token %s", oauth2Token.AccessToken)},
+		}
+
+		response, err := client.Do(req)
+		if err != nil {
+			log.Debug("Failed to request github user email: ", err)
+			return user, err
+		}
+
+		defer response.Body.Close()
+		body, err := ioutil.ReadAll(response.Body)
+		if err != nil {
+			log.Debug("Failed to read github user email response body: ", err)
+			return user, fmt.Errorf("failed to read github response body: %s", err.Error())
+		}
+		if response.StatusCode >= 400 {
+			log.Debug("Failed to request github user email: ", string(body))
+			return user, fmt.Errorf("failed to request github user info: %s", string(body))
+		}
+
+		emailData := []GithubUserEmails{}
+		err = json.Unmarshal(body, &emailData)
+		if err != nil {
+			log.Debug("Failed to parse github user email: ", err)
+		}
+
+		for _, userEmail := range emailData {
+			email = userEmail.Email
+			if userEmail.Primary {
+				break
+			}
+		}
+	}
 
 	user = models.User{
 		GivenName:  &firstName,
 		FamilyName: &lastName,
 		Picture:    &picture,
-		Email:      userRawData["email"],
+		Email:      email,
 	}
 
 	return user, nil
@@ -462,8 +520,6 @@ func processAppleUserInfo(code string) (models.User, error) {
 		return user, fmt.Errorf("invalid apple exchange code: %s", err.Error())
 	}
 
-	fmt.Println("=> token", oauth2Token.AccessToken)
-
 	// Extract the ID Token from OAuth2 token.
 	rawIDToken, ok := oauth2Token.Extra("id_token").(string)
 	if !ok {
@@ -471,39 +527,39 @@ func processAppleUserInfo(code string) (models.User, error) {
 		return user, fmt.Errorf("unable to extract id_token")
 	}
 
-	fmt.Println("=> rawIDToken", rawIDToken)
-
 	tokenSplit := strings.Split(rawIDToken, ".")
 	claimsData := tokenSplit[1]
-	decodedClaimsData, err := crypto.DecryptB64(claimsData)
+	decodedClaimsData, err := base64.RawURLEncoding.DecodeString(claimsData)
 	if err != nil {
-		log.Debug("Failed to decrypt claims data: ", err)
+		log.Debugf("Failed to decrypt claims %s: %s", claimsData, err.Error())
 		return user, fmt.Errorf("failed to decrypt claims data: %s", err.Error())
 	}
-	fmt.Println("=> decoded claims data", decodedClaimsData)
 
 	claims := make(map[string]interface{})
-	err = json.Unmarshal([]byte(decodedClaimsData), &claims)
+	err = json.Unmarshal(decodedClaimsData, &claims)
 	if err != nil {
 		log.Debug("Failed to unmarshal claims data: ", err)
 		return user, fmt.Errorf("failed to unmarshal claims data: %s", err.Error())
 	}
 
-	fmt.Println("=> claims", claims)
-
 	if val, ok := claims["email"]; !ok {
-		log.Debug("Failed to extract email from claims")
+		log.Debug("Failed to extract email from claims.")
-		return user, fmt.Errorf("unable to extract email")
+		return user, fmt.Errorf("unable to extract email, please check the scopes enabled for your app. It needs `email`, `name` scopes")
 	} else {
 		user.Email = val.(string)
 	}
 
 	if val, ok := claims["name"]; ok {
 		nameData := val.(map[string]interface{})
-		givenName := nameData["firstName"].(string)
+		if nameVal, ok := nameData["firstName"]; ok {
-		familyName := nameData["lastName"].(string)
+			givenName := nameVal.(string)
-		user.GivenName = &givenName
+			user.GivenName = &givenName
-		user.FamilyName = &familyName
+		}
+
+		if nameVal, ok := nameData["lastName"]; ok {
+			familyName := nameVal.(string)
+			user.FamilyName = &familyName
+		}
 	}
 
 	return user, err

server/handlers/oauth_login.go

@@ -100,13 +100,13 @@ func OAuthLoginHandler() gin.HandlerFunc {
 		provider := c.Param("oauth_provider")
 		isProviderConfigured := true
 		switch provider {
-		case constants.SignupMethodGoogle:
+		case constants.AuthRecipeMethodGoogle:
 			if oauth.OAuthProviders.GoogleConfig == nil {
 				log.Debug("Google OAuth provider is not configured")
 				isProviderConfigured = false
 				break
 			}
-			err := memorystore.Provider.SetState(oauthStateString, constants.SignupMethodGoogle)
+			err := memorystore.Provider.SetState(oauthStateString, constants.AuthRecipeMethodGoogle)
 			if err != nil {
 				log.Debug("Error setting state: ", err)
 				c.JSON(500, gin.H{
@@ -115,16 +115,16 @@ func OAuthLoginHandler() gin.HandlerFunc {
 				return
 			}
 			// during the init of OAuthProvider authorizer url might be empty
-			oauth.OAuthProviders.GoogleConfig.RedirectURL = hostname + "/oauth_callback/" + constants.SignupMethodGoogle
+			oauth.OAuthProviders.GoogleConfig.RedirectURL = hostname + "/oauth_callback/" + constants.AuthRecipeMethodGoogle
 			url := oauth.OAuthProviders.GoogleConfig.AuthCodeURL(oauthStateString)
 			c.Redirect(http.StatusTemporaryRedirect, url)
-		case constants.SignupMethodGithub:
+		case constants.AuthRecipeMethodGithub:
 			if oauth.OAuthProviders.GithubConfig == nil {
 				log.Debug("Github OAuth provider is not configured")
 				isProviderConfigured = false
 				break
 			}
-			err := memorystore.Provider.SetState(oauthStateString, constants.SignupMethodGithub)
+			err := memorystore.Provider.SetState(oauthStateString, constants.AuthRecipeMethodGithub)
 			if err != nil {
 				log.Debug("Error setting state: ", err)
 				c.JSON(500, gin.H{
@@ -132,16 +132,16 @@ func OAuthLoginHandler() gin.HandlerFunc {
 				})
 				return
 			}
-			oauth.OAuthProviders.GithubConfig.RedirectURL = hostname + "/oauth_callback/" + constants.SignupMethodGithub
+			oauth.OAuthProviders.GithubConfig.RedirectURL = hostname + "/oauth_callback/" + constants.AuthRecipeMethodGithub
 			url := oauth.OAuthProviders.GithubConfig.AuthCodeURL(oauthStateString)
 			c.Redirect(http.StatusTemporaryRedirect, url)
-		case constants.SignupMethodFacebook:
+		case constants.AuthRecipeMethodFacebook:
 			if oauth.OAuthProviders.FacebookConfig == nil {
 				log.Debug("Facebook OAuth provider is not configured")
 				isProviderConfigured = false
 				break
 			}
-			err := memorystore.Provider.SetState(oauthStateString, constants.SignupMethodFacebook)
+			err := memorystore.Provider.SetState(oauthStateString, constants.AuthRecipeMethodFacebook)
 			if err != nil {
 				log.Debug("Error setting state: ", err)
 				c.JSON(500, gin.H{
@@ -149,16 +149,16 @@ func OAuthLoginHandler() gin.HandlerFunc {
 				})
 				return
 			}
-			oauth.OAuthProviders.FacebookConfig.RedirectURL = hostname + "/oauth_callback/" + constants.SignupMethodFacebook
+			oauth.OAuthProviders.FacebookConfig.RedirectURL = hostname + "/oauth_callback/" + constants.AuthRecipeMethodFacebook
 			url := oauth.OAuthProviders.FacebookConfig.AuthCodeURL(oauthStateString)
 			c.Redirect(http.StatusTemporaryRedirect, url)
-		case constants.SignupMethodLinkedIn:
+		case constants.AuthRecipeMethodLinkedIn:
 			if oauth.OAuthProviders.LinkedInConfig == nil {
 				log.Debug("Linkedin OAuth provider is not configured")
 				isProviderConfigured = false
 				break
 			}
-			err := memorystore.Provider.SetState(oauthStateString, constants.SignupMethodLinkedIn)
+			err := memorystore.Provider.SetState(oauthStateString, constants.AuthRecipeMethodLinkedIn)
 			if err != nil {
 				log.Debug("Error setting state: ", err)
 				c.JSON(500, gin.H{
@@ -166,16 +166,16 @@ func OAuthLoginHandler() gin.HandlerFunc {
 				})
 				return
 			}
-			oauth.OAuthProviders.LinkedInConfig.RedirectURL = hostname + "/oauth_callback/" + constants.SignupMethodLinkedIn
+			oauth.OAuthProviders.LinkedInConfig.RedirectURL = hostname + "/oauth_callback/" + constants.AuthRecipeMethodLinkedIn
 			url := oauth.OAuthProviders.LinkedInConfig.AuthCodeURL(oauthStateString)
 			c.Redirect(http.StatusTemporaryRedirect, url)
-		case constants.SignupMethodApple:
+		case constants.AuthRecipeMethodApple:
 			if oauth.OAuthProviders.AppleConfig == nil {
 				log.Debug("Apple OAuth provider is not configured")
 				isProviderConfigured = false
 				break
 			}
-			err := memorystore.Provider.SetState(oauthStateString, constants.SignupMethodApple)
+			err := memorystore.Provider.SetState(oauthStateString, constants.AuthRecipeMethodApple)
 			if err != nil {
 				log.Debug("Error setting state: ", err)
 				c.JSON(500, gin.H{
@@ -183,8 +183,10 @@ func OAuthLoginHandler() gin.HandlerFunc {
 				})
 				return
 			}
-			oauth.OAuthProviders.AppleConfig.RedirectURL = hostname + "/oauth_callback/" + constants.SignupMethodApple
+			oauth.OAuthProviders.AppleConfig.RedirectURL = hostname + "/oauth_callback/" + constants.AuthRecipeMethodApple
-			url := oauth.OAuthProviders.AppleConfig.AuthCodeURL(oauthStateString, oauth2.SetAuthURLParam("response_mode", "form_post"))
+			// there is scope encoding issue with oauth2 and how apple expects, hence added scope manually
+			// check: https://github.com/golang/oauth2/issues/449
+			url := oauth.OAuthProviders.AppleConfig.AuthCodeURL(oauthStateString, oauth2.SetAuthURLParam("response_mode", "form_post")) + "&scope=name email"
 			c.Redirect(http.StatusTemporaryRedirect, url)
 		default:
 			log.Debug("Invalid oauth provider: ", provider)

server/handlers/revoke_refresh_token.go

@@ -12,8 +12,8 @@ import (
 	"github.com/authorizerdev/authorizer/server/token"
 )
 
-// Revoke handler to revoke refresh token
+// RevokeRefreshTokenHandler handler to revoke refresh token
-func RevokeHandler() gin.HandlerFunc {
+func RevokeRefreshTokenHandler() gin.HandlerFunc {
 	return func(gc *gin.Context) {
 		var reqBody map[string]string
 		if err := gc.BindJSON(&reqBody); err != nil {
@@ -56,7 +56,14 @@ func RevokeHandler() gin.HandlerFunc {
 			return
 		}
 
-		memorystore.Provider.DeleteUserSession(claims["sub"].(string), claims["nonce"].(string))
+		userID := claims["sub"].(string)
+		loginMethod := claims["login_method"]
+		sessionToken := userID
+		if loginMethod != nil && loginMethod != "" {
+			sessionToken = loginMethod.(string) + ":" + userID
+		}
+
+		memorystore.Provider.DeleteUserSession(sessionToken, claims["nonce"].(string))
 
 		gc.JSON(http.StatusOK, gin.H{
 			"message": "Token revoked successfully",

server/handlers/token.go

@@ -72,6 +72,9 @@ func TokenHandler() gin.HandlerFunc {
 
 		var userID string
 		var roles, scope []string
+		loginMethod := ""
+		sessionKey := ""
+
 		if isAuthorizationCodeGrant {
 
 			if codeVerifier == "" {
@@ -134,8 +137,13 @@ func TokenHandler() gin.HandlerFunc {
 			userID = claims.Subject
 			roles = claims.Roles
 			scope = claims.Scope
+			loginMethod = claims.LoginMethod
 			// rollover the session for security
-			go memorystore.Provider.DeleteUserSession(userID, claims.Nonce)
+			sessionKey = userID
+			if loginMethod != "" {
+				sessionKey = loginMethod + ":" + userID
+			}
+			go memorystore.Provider.DeleteUserSession(sessionKey, claims.Nonce)
 		} else {
 			// validate refresh token
 			if refreshToken == "" {
@@ -155,6 +163,7 @@ func TokenHandler() gin.HandlerFunc {
 				})
 			}
 			userID = claims["sub"].(string)
+			loginMethod := claims["login_method"]
 			rolesInterface := claims["roles"].([]interface{})
 			scopeInterface := claims["scope"].([]interface{})
 			for _, v := range rolesInterface {
@@ -163,11 +172,25 @@ func TokenHandler() gin.HandlerFunc {
 			for _, v := range scopeInterface {
 				scope = append(scope, v.(string))
 			}
+
+			sessionKey = userID
+			if loginMethod != nil && loginMethod != "" {
+				sessionKey = loginMethod.(string) + ":" + sessionKey
+			}
 			// remove older refresh token and rotate it for security
-			go memorystore.Provider.DeleteUserSession(userID, claims["nonce"].(string))
+			go memorystore.Provider.DeleteUserSession(sessionKey, claims["nonce"].(string))
 		}
 
-		user, err := db.Provider.GetUserByID(userID)
+		if sessionKey == "" {
+			log.Debug("Error getting sessionKey: ", sessionKey, loginMethod)
+			gc.JSON(http.StatusUnauthorized, gin.H{
+				"error":             "unauthorized",
+				"error_description": "User not found",
+			})
+			return
+		}
+
+		user, err := db.Provider.GetUserByID(gc, userID)
 		if err != nil {
 			log.Debug("Error getting user: ", err)
 			gc.JSON(http.StatusUnauthorized, gin.H{
@@ -177,7 +200,7 @@ func TokenHandler() gin.HandlerFunc {
 			return
 		}
 
-		authToken, err := token.CreateAuthToken(gc, user, roles, scope)
+		authToken, err := token.CreateAuthToken(gc, user, roles, scope, loginMethod)
 		if err != nil {
 			log.Debug("Error creating auth token: ", err)
 			gc.JSON(http.StatusUnauthorized, gin.H{
@@ -186,8 +209,8 @@ func TokenHandler() gin.HandlerFunc {
 			})
 			return
 		}
-		memorystore.Provider.SetUserSession(user.ID, constants.TokenTypeSessionToken+"_"+authToken.FingerPrint, authToken.FingerPrintHash)
+		memorystore.Provider.SetUserSession(sessionKey, constants.TokenTypeSessionToken+"_"+authToken.FingerPrint, authToken.FingerPrintHash)
-		memorystore.Provider.SetUserSession(user.ID, constants.TokenTypeAccessToken+"_"+authToken.FingerPrint, authToken.AccessToken.Token)
+		memorystore.Provider.SetUserSession(sessionKey, constants.TokenTypeAccessToken+"_"+authToken.FingerPrint, authToken.AccessToken.Token)
 		cookie.SetSession(gc, authToken.FingerPrintHash)
 
 		expiresIn := authToken.AccessToken.ExpiresAt - time.Now().Unix()
@@ -205,7 +228,7 @@ func TokenHandler() gin.HandlerFunc {
 
 		if authToken.RefreshToken != nil {
 			res["refresh_token"] = authToken.RefreshToken.Token
-			memorystore.Provider.SetUserSession(user.ID, constants.TokenTypeRefreshToken+"_"+authToken.FingerPrint, authToken.RefreshToken.Token)
+			memorystore.Provider.SetUserSession(sessionKey, constants.TokenTypeRefreshToken+"_"+authToken.FingerPrint, authToken.RefreshToken.Token)
 		}
 
 		gc.JSON(http.StatusOK, res)

server/handlers/userinfo.go

@@ -31,7 +31,7 @@ func UserInfoHandler() gin.HandlerFunc {
 		}
 
 		userID := claims["sub"].(string)
-		user, err := db.Provider.GetUserByID(userID)
+		user, err := db.Provider.GetUserByID(gc, userID)
 		if err != nil {
 			log.Debug("Error getting user: ", err)
 			gc.JSON(http.StatusUnauthorized, gin.H{

server/handlers/verify_email.go

@@ -33,7 +33,7 @@ func VerifyEmailHandler() gin.HandlerFunc {
 			return
 		}
 
-		verificationRequest, err := db.Provider.GetVerificationRequestByToken(tokenInQuery)
+		verificationRequest, err := db.Provider.GetVerificationRequestByToken(c, tokenInQuery)
 		if err != nil {
 			log.Debug("Error getting verification request: ", err)
 			errorRes["error_description"] = err.Error()
@@ -58,7 +58,7 @@ func VerifyEmailHandler() gin.HandlerFunc {
 			return
 		}
 
-		user, err := db.Provider.GetUserByEmail(verificationRequest.Email)
+		user, err := db.Provider.GetUserByEmail(c, verificationRequest.Email)
 		if err != nil {
 			log.Debug("Error getting user: ", err)
 			errorRes["error_description"] = err.Error()
@@ -66,14 +66,16 @@ func VerifyEmailHandler() gin.HandlerFunc {
 			return
 		}
 
+		isSignUp := false
 		// update email_verified_at in users table
 		if user.EmailVerifiedAt == nil {
 			now := time.Now().Unix()
 			user.EmailVerifiedAt = &now
-			db.Provider.UpdateUser(user)
+			isSignUp = true
+			db.Provider.UpdateUser(c, user)
 		}
 		// delete from verification table
-		db.Provider.DeleteVerificationRequest(verificationRequest)
+		db.Provider.DeleteVerificationRequest(c, verificationRequest)
 
 		state := strings.TrimSpace(c.Query("state"))
 		redirectURL := strings.TrimSpace(c.Query("redirect_uri"))
@@ -92,7 +94,11 @@ func VerifyEmailHandler() gin.HandlerFunc {
 		} else {
 			scope = strings.Split(scopeString, " ")
 		}
-		authToken, err := token.CreateAuthToken(c, user, roles, scope)
+		loginMethod := constants.AuthRecipeMethodBasicAuth
+		if verificationRequest.Identifier == constants.VerificationTypeMagicLinkLogin {
+			loginMethod = constants.AuthRecipeMethodMagicLinkLogin
+		}
+		authToken, err := token.CreateAuthToken(c, user, roles, scope, loginMethod)
 		if err != nil {
 			log.Debug("Error creating auth token: ", err)
 			errorRes["error_description"] = err.Error()
@@ -107,13 +113,14 @@ func VerifyEmailHandler() gin.HandlerFunc {
 
 		params := "access_token=" + authToken.AccessToken.Token + "&token_type=bearer&expires_in=" + strconv.FormatInt(expiresIn, 10) + "&state=" + state + "&id_token=" + authToken.IDToken.Token
 
+		sessionKey := loginMethod + ":" + user.ID
 		cookie.SetSession(c, authToken.FingerPrintHash)
-		memorystore.Provider.SetUserSession(user.ID, constants.TokenTypeSessionToken+"_"+authToken.FingerPrint, authToken.FingerPrintHash)
+		memorystore.Provider.SetUserSession(sessionKey, constants.TokenTypeSessionToken+"_"+authToken.FingerPrint, authToken.FingerPrintHash)
-		memorystore.Provider.SetUserSession(user.ID, constants.TokenTypeAccessToken+"_"+authToken.FingerPrint, authToken.AccessToken.Token)
+		memorystore.Provider.SetUserSession(sessionKey, constants.TokenTypeAccessToken+"_"+authToken.FingerPrint, authToken.AccessToken.Token)
 
 		if authToken.RefreshToken != nil {
 			params = params + `&refresh_token=` + authToken.RefreshToken.Token
-			memorystore.Provider.SetUserSession(user.ID, constants.TokenTypeRefreshToken+"_"+authToken.FingerPrint, authToken.RefreshToken.Token)
+			memorystore.Provider.SetUserSession(sessionKey, constants.TokenTypeRefreshToken+"_"+authToken.FingerPrint, authToken.RefreshToken.Token)
 		}
 
 		if redirectURL == "" {
@@ -126,11 +133,19 @@ func VerifyEmailHandler() gin.HandlerFunc {
 			redirectURL = redirectURL + "?" + strings.TrimPrefix(params, "&")
 		}
 
-		go db.Provider.AddSession(models.Session{
+		go func() {
-			UserID:    user.ID,
+			if isSignUp {
-			UserAgent: utils.GetUserAgent(c.Request),
+				utils.RegisterEvent(c, constants.UserSignUpWebhookEvent, loginMethod, user)
-			IP:        utils.GetIP(c.Request),
+			} else {
-		})
+				utils.RegisterEvent(c, constants.UserLoginWebhookEvent, loginMethod, user)
+			}
+
+			db.Provider.AddSession(c, models.Session{
+				UserID:    user.ID,
+				UserAgent: utils.GetUserAgent(c.Request),
+				IP:        utils.GetIP(c.Request),
+			})
+		}()
 
 		c.Redirect(http.StatusTemporaryRedirect, redirectURL)
 	}

server/memorystore/memory_store.go

@@ -30,6 +30,7 @@ func InitMemStore() error {
 		constants.EnvKeyDisableEmailVerification:   false,
 		constants.EnvKeyDisableLoginPage:           false,
 		constants.EnvKeyDisableSignUp:              false,
+		constants.EnvKeyDisableStrongPassword:      false,
 	}
 
 	requiredEnvs := RequiredEnvStoreObj.GetRequiredEnv()

server/memorystore/providers/inmemory/store.go

@@ -26,24 +26,34 @@ func (c *provider) GetUserSession(userId, sessionToken string) (string, error) {
 
 // DeleteAllUserSessions deletes all the user sessions from in-memory store.
 func (c *provider) DeleteAllUserSessions(userId string) error {
-	if os.Getenv("ENV") != constants.TestEnv {
+	namespaces := []string{
-		c.mutex.Lock()
+		constants.AuthRecipeMethodBasicAuth,
-		defer c.mutex.Unlock()
+		constants.AuthRecipeMethodMagicLinkLogin,
+		constants.AuthRecipeMethodApple,
+		constants.AuthRecipeMethodFacebook,
+		constants.AuthRecipeMethodGithub,
+		constants.AuthRecipeMethodGoogle,
+		constants.AuthRecipeMethodLinkedIn,
+	}
+
+	for _, namespace := range namespaces {
+		c.sessionStore.RemoveAll(namespace + ":" + userId)
 	}
-	c.sessionStore.RemoveAll(userId)
 	return nil
 }
 
 // DeleteUserSession deletes the user session from the in-memory store.
 func (c *provider) DeleteUserSession(userId, sessionToken string) error {
-	if os.Getenv("ENV") != constants.TestEnv {
-		c.mutex.Lock()
-		defer c.mutex.Unlock()
-	}
 	c.sessionStore.Remove(userId, sessionToken)
 	return nil
 }
 
+// DeleteSessionForNamespace to delete session for a given namespace example google,github
+func (c *provider) DeleteSessionForNamespace(namespace string) error {
+	c.sessionStore.RemoveByNamespace(namespace)
+	return nil
+}
+
 // SetState sets the state in the in-memory store.
 func (c *provider) SetState(key, state string) error {
 	if os.Getenv("ENV") != constants.TestEnv {

server/memorystore/providers/inmemory/stores/env_store.go

@@ -1,10 +1,7 @@
 package stores
 
 import (
-	"os"
 	"sync"
-
-	"github.com/authorizerdev/authorizer/server/constants"
 )
 
 // EnvStore struct to store the env variables
@@ -23,12 +20,10 @@ func NewEnvStore() *EnvStore {
 
 // UpdateEnvStore to update the whole env store object
 func (e *EnvStore) UpdateStore(store map[string]interface{}) {
-	if os.Getenv("ENV") != constants.TestEnv {
+	e.mutex.Lock()
-		e.mutex.Lock()
+	defer e.mutex.Unlock()
-		defer e.mutex.Unlock()
-	}
-	// just override the keys + new keys
 
+	// just override the keys + new keys
 	for key, value := range store {
 		e.store[key] = value
 	}
@@ -46,9 +41,8 @@ func (e *EnvStore) Get(key string) interface{} {
 
 // Set sets the value of the key in env store
 func (e *EnvStore) Set(key string, value interface{}) {
-	if os.Getenv("ENV") != constants.TestEnv {
+	e.mutex.Lock()
-		e.mutex.Lock()
+	defer e.mutex.Unlock()
-		defer e.mutex.Unlock()
+
-	}
 	e.store[key] = value
 }

server/memorystore/providers/inmemory/stores/session_store.go

@@ -1,10 +1,8 @@
 package stores
 
 import (
-	"os"
+	"strings"
 	"sync"
-
-	"github.com/authorizerdev/authorizer/server/constants"
 )
 
 // SessionStore struct to store the env variables
@@ -28,10 +26,9 @@ func (s *SessionStore) Get(key, subKey string) string {
 
 // Set sets the value of the key in state store
 func (s *SessionStore) Set(key string, subKey, value string) {
-	if os.Getenv("ENV") != constants.TestEnv {
+	s.mutex.Lock()
-		s.mutex.Lock()
+	defer s.mutex.Unlock()
-		defer s.mutex.Unlock()
+
-	}
 	if _, ok := s.store[key]; !ok {
 		s.store[key] = make(map[string]string)
 	}
@@ -40,19 +37,15 @@ func (s *SessionStore) Set(key string, subKey, value string) {
 
 // RemoveAll all values for given key
 func (s *SessionStore) RemoveAll(key string) {
-	if os.Getenv("ENV") != constants.TestEnv {
+	s.mutex.Lock()
-		s.mutex.Lock()
+	defer s.mutex.Unlock()
-		defer s.mutex.Unlock()
-	}
 	delete(s.store, key)
 }
 
 // Remove value for given key and subkey
 func (s *SessionStore) Remove(key, subKey string) {
-	if os.Getenv("ENV") != constants.TestEnv {
+	s.mutex.Lock()
-		s.mutex.Lock()
+	defer s.mutex.Unlock()
-		defer s.mutex.Unlock()
-	}
 	if _, ok := s.store[key]; ok {
 		delete(s.store[key], subKey)
 	}
@@ -65,3 +58,15 @@ func (s *SessionStore) GetAll(key string) map[string]string {
 	}
 	return s.store[key]
 }
+
+// RemoveByNamespace to delete session for a given namespace example google,github
+func (s *SessionStore) RemoveByNamespace(namespace string) error {
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+	for key := range s.store {
+		if strings.Contains(key, namespace+":") {
+			delete(s.store, key)
+		}
+	}
+	return nil
+}

server/memorystore/providers/inmemory/stores/state_store.go

@@ -1,10 +1,7 @@
 package stores
 
 import (
-	"os"
 	"sync"
-
-	"github.com/authorizerdev/authorizer/server/constants"
 )
 
 // StateStore struct to store the env variables
@@ -28,19 +25,16 @@ func (s *StateStore) Get(key string) string {
 
 // Set sets the value of the key in state store
 func (s *StateStore) Set(key string, value string) {
-	if os.Getenv("ENV") != constants.TestEnv {
+	s.mutex.Lock()
-		s.mutex.Lock()
+	defer s.mutex.Unlock()
-		defer s.mutex.Unlock()
+
-	}
 	s.store[key] = value
 }
 
 // Remove removes the key from state store
 func (s *StateStore) Remove(key string) {
-	if os.Getenv("ENV") != constants.TestEnv {
+	s.mutex.Lock()
-		s.mutex.Lock()
+	defer s.mutex.Unlock()
-		defer s.mutex.Unlock()
-	}
 
 	delete(s.store, key)
 }

server/memorystore/providers/providers.go

@@ -12,6 +12,8 @@ type Provider interface {
 	DeleteUserSession(userId, key string) error
 	// DeleteAllSessions deletes all the sessions from the session store
 	DeleteAllUserSessions(userId string) error
+	// DeleteSessionForNamespace deletes the session for a given namespace
+	DeleteSessionForNamespace(namespace string) error
 
 	// SetState sets the login state (key, value form) in the session store
 	SetState(key, state string) error

server/memorystore/providers/redis/store.go

@@ -63,11 +63,48 @@ func (c *provider) DeleteUserSession(userId, key string) error {
 
 // DeleteAllUserSessions deletes all the user session from redis
 func (c *provider) DeleteAllUserSessions(userID string) error {
-	err := c.store.Del(c.ctx, userID).Err()
+	namespaces := []string{
-	if err != nil {
+		constants.AuthRecipeMethodBasicAuth,
-		log.Debug("Error deleting all user sessions from redis: ", err)
+		constants.AuthRecipeMethodMagicLinkLogin,
-		return err
+		constants.AuthRecipeMethodApple,
+		constants.AuthRecipeMethodFacebook,
+		constants.AuthRecipeMethodGithub,
+		constants.AuthRecipeMethodGoogle,
+		constants.AuthRecipeMethodLinkedIn,
 	}
+	for _, namespace := range namespaces {
+		err := c.store.Del(c.ctx, namespace+":"+userID).Err()
+		if err != nil {
+			log.Debug("Error deleting all user sessions from redis: ", err)
+			return err
+		}
+	}
+	return nil
+}
+
+// DeleteSessionForNamespace to delete session for a given namespace example google,github
+func (c *provider) DeleteSessionForNamespace(namespace string) error {
+	var cursor uint64
+	for {
+		keys := []string{}
+		keys, cursor, err := c.store.Scan(c.ctx, cursor, namespace+":*", 0).Result()
+		if err != nil {
+			log.Debugf("Error scanning keys for %s namespace: %s", namespace, err.Error())
+			return err
+		}
+
+		for _, key := range keys {
+			err := c.store.Del(c.ctx, key).Err()
+			if err != nil {
+				log.Debugf("Error deleting sessions for %s namespace: %s", namespace, err.Error())
+				return err
+			}
+		}
+		if cursor == 0 { // no more keys
+			break
+		}
+	}
+
 	return nil
 }
 
@@ -123,7 +160,7 @@ func (c *provider) GetEnvStore() (map[string]interface{}, error) {
 		return nil, err
 	}
 	for key, value := range data {
-		if key == constants.EnvKeyDisableBasicAuthentication || key == constants.EnvKeyDisableEmailVerification || key == constants.EnvKeyDisableLoginPage || key == constants.EnvKeyDisableMagicLinkLogin || key == constants.EnvKeyDisableRedisForEnv || key == constants.EnvKeyDisableSignUp {
+		if key == constants.EnvKeyDisableBasicAuthentication || key == constants.EnvKeyDisableEmailVerification || key == constants.EnvKeyDisableLoginPage || key == constants.EnvKeyDisableMagicLinkLogin || key == constants.EnvKeyDisableRedisForEnv || key == constants.EnvKeyDisableSignUp || key == constants.EnvKeyDisableStrongPassword {
 			boolValue, err := strconv.ParseBool(value)
 			if err != nil {
 				return res, err

server/oauth/oauth.go

@@ -130,7 +130,6 @@ func InitOAuth() error {
 				AuthURL:  "https://appleid.apple.com/auth/authorize",
 				TokenURL: "https://appleid.apple.com/auth/token",
 			},
-			Scopes: []string{"openid", "name", "email"},
 		}
 	}
 

server/refs/bool.go

@@ -0,0 +1,14 @@
+package refs
+
+// NewBoolRef returns a reference to a bool with given value
+func NewBoolRef(v bool) *bool {
+	return &v
+}
+
+// BoolValue returns the value of the given bool ref
+func BoolValue(r *bool) bool {
+	if r == nil {
+		return false
+	}
+	return *r
+}

server/refs/int.go

@@ -0,0 +1,14 @@
+package refs
+
+// NewInt64Ref returns a reference to a int64 with given value
+func NewInt64Ref(v int64) *int64 {
+	return &v
+}
+
+// Int64Value returns the value of the given bool ref
+func Int64Value(r *int64) int64 {
+	if r == nil {
+		return 0
+	}
+	return *r
+}

server/refs/string.go

@@ -0,0 +1,19 @@
+package refs
+
+// NewStringRef returns a reference to a string with given value
+func NewStringRef(v string) *string {
+	return &v
+}
+
+// StringValue returns the value of the given string ref
+func StringValue(r *string, defaultValue ...string) string {
+	if r != nil {
+		return *r
+	}
+	if len(defaultValue) > 0 {
+		return defaultValue[0]
+	}
+	return ""
+}
+
+

server/resolvers/add_email_template.go

@@ -0,0 +1,53 @@
+package resolvers
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/authorizerdev/authorizer/server/db"
+	"github.com/authorizerdev/authorizer/server/db/models"
+	"github.com/authorizerdev/authorizer/server/graph/model"
+	"github.com/authorizerdev/authorizer/server/token"
+	"github.com/authorizerdev/authorizer/server/utils"
+	"github.com/authorizerdev/authorizer/server/validators"
+	log "github.com/sirupsen/logrus"
+)
+
+// TODO add template validator
+
+// AddEmailTemplateResolver resolver for add email template mutation
+func AddEmailTemplateResolver(ctx context.Context, params model.AddEmailTemplateRequest) (*model.Response, error) {
+	gc, err := utils.GinContextFromContext(ctx)
+	if err != nil {
+		log.Debug("Failed to get GinContext: ", err)
+		return nil, err
+	}
+
+	if !token.IsSuperAdmin(gc) {
+		log.Debug("Not logged in as super admin")
+		return nil, fmt.Errorf("unauthorized")
+	}
+
+	if !validators.IsValidEmailTemplateEventName(params.EventName) {
+		log.Debug("Invalid Event Name: ", params.EventName)
+		return nil, fmt.Errorf("invalid event name %s", params.EventName)
+	}
+
+	if strings.TrimSpace(params.Template) == "" {
+		return nil, fmt.Errorf("empty template not allowed")
+	}
+
+	_, err = db.Provider.AddEmailTemplate(ctx, models.EmailTemplate{
+		EventName: params.EventName,
+		Template:  params.Template,
+	})
+	if err != nil {
+		log.Debug("Failed to add email template: ", err)
+		return nil, err
+	}
+
+	return &model.Response{
+		Message: `Email template added successfully`,
+	}, nil
+}

server/resolvers/add_webhook.go

@@ -0,0 +1,60 @@
+package resolvers
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"github.com/authorizerdev/authorizer/server/db"
+	"github.com/authorizerdev/authorizer/server/db/models"
+	"github.com/authorizerdev/authorizer/server/graph/model"
+	"github.com/authorizerdev/authorizer/server/token"
+	"github.com/authorizerdev/authorizer/server/utils"
+	"github.com/authorizerdev/authorizer/server/validators"
+	log "github.com/sirupsen/logrus"
+)
+
+// AddWebhookResolver resolver for add webhook mutation
+func AddWebhookResolver(ctx context.Context, params model.AddWebhookRequest) (*model.Response, error) {
+	gc, err := utils.GinContextFromContext(ctx)
+	if err != nil {
+		log.Debug("Failed to get GinContext: ", err)
+		return nil, err
+	}
+
+	if !token.IsSuperAdmin(gc) {
+		log.Debug("Not logged in as super admin")
+		return nil, fmt.Errorf("unauthorized")
+	}
+
+	if !validators.IsValidWebhookEventName(params.EventName) {
+		log.Debug("Invalid Event Name: ", params.EventName)
+		return nil, fmt.Errorf("invalid event name %s", params.EventName)
+	}
+
+	if strings.TrimSpace(params.Endpoint) == "" {
+		log.Debug("empty endpoint not allowed")
+		return nil, fmt.Errorf("empty endpoint not allowed")
+	}
+
+	headerBytes, err := json.Marshal(params.Headers)
+	if err != nil {
+		return nil, err
+	}
+
+	_, err = db.Provider.AddWebhook(ctx, models.Webhook{
+		EventName: params.EventName,
+		EndPoint:  params.Endpoint,
+		Enabled:   params.Enabled,
+		Headers:   string(headerBytes),
+	})
+	if err != nil {
+		log.Debug("Failed to add webhook: ", err)
+		return nil, err
+	}
+
+	return &model.Response{
+		Message: `Webhook added successfully`,
+	}, nil
+}

server/resolvers/admin_signup.go

@@ -58,7 +58,7 @@ func AdminSignupResolver(ctx context.Context, params model.AdminSignupInput) (*m
 		return res, err
 	}
 
-	env, err := db.Provider.GetEnv()
+	env, err := db.Provider.GetEnv(ctx)
 	if err != nil {
 		log.Debug("Failed to get env: ", err)
 		return res, err
@@ -71,7 +71,7 @@ func AdminSignupResolver(ctx context.Context, params model.AdminSignupInput) (*m
 	}
 
 	env.EnvData = envData
-	if _, err := db.Provider.UpdateEnv(env); err != nil {
+	if _, err := db.Provider.UpdateEnv(ctx, env); err != nil {
 		log.Debug("Failed to update env: ", err)
 		return res, err
 	}

server/resolvers/delete_email_template.go

@@ -0,0 +1,49 @@
+package resolvers
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/authorizerdev/authorizer/server/db"
+	"github.com/authorizerdev/authorizer/server/graph/model"
+	"github.com/authorizerdev/authorizer/server/token"
+	"github.com/authorizerdev/authorizer/server/utils"
+	log "github.com/sirupsen/logrus"
+)
+
+// DeleteEmailTemplateResolver resolver to delete email template and its relevant logs
+func DeleteEmailTemplateResolver(ctx context.Context, params model.DeleteEmailTemplateRequest) (*model.Response, error) {
+	gc, err := utils.GinContextFromContext(ctx)
+	if err != nil {
+		log.Debug("Failed to get GinContext: ", err)
+		return nil, err
+	}
+
+	if !token.IsSuperAdmin(gc) {
+		log.Debug("Not logged in as super admin")
+		return nil, fmt.Errorf("unauthorized")
+	}
+
+	if params.ID == "" {
+		log.Debug("email template is required")
+		return nil, fmt.Errorf("email template ID required")
+	}
+
+	log := log.WithField("email_template_id", params.ID)
+
+	emailTemplate, err := db.Provider.GetEmailTemplateByID(ctx, params.ID)
+	if err != nil {
+		log.Debug("failed to get email template: ", err)
+		return nil, err
+	}
+
+	err = db.Provider.DeleteEmailTemplate(ctx, emailTemplate)
+	if err != nil {
+		log.Debug("failed to delete email template: ", err)
+		return nil, err
+	}
+
+	return &model.Response{
+		Message: "Email templated deleted successfully",
+	}, nil
+}

server/resolvers/delete_user.go

@@ -6,6 +6,7 @@ import (
 
 	log "github.com/sirupsen/logrus"
 
+	"github.com/authorizerdev/authorizer/server/constants"
 	"github.com/authorizerdev/authorizer/server/db"
 	"github.com/authorizerdev/authorizer/server/graph/model"
 	"github.com/authorizerdev/authorizer/server/memorystore"
@@ -32,15 +33,13 @@ func DeleteUserResolver(ctx context.Context, params model.DeleteUserInput) (*mod
 		"email": params.Email,
 	})
 
-	user, err := db.Provider.GetUserByEmail(params.Email)
+	user, err := db.Provider.GetUserByEmail(ctx, params.Email)
 	if err != nil {
 		log.Debug("Failed to get user from DB: ", err)
 		return res, err
 	}
 
-	go memorystore.Provider.DeleteAllUserSessions(user.ID)
+	err = db.Provider.DeleteUser(ctx, user)
-
-	err = db.Provider.DeleteUser(user)
 	if err != nil {
 		log.Debug("Failed to delete user: ", err)
 		return res, err
@@ -50,5 +49,10 @@ func DeleteUserResolver(ctx context.Context, params model.DeleteUserInput) (*mod
 		Message: `user deleted successfully`,
 	}
 
+	go func() {
+		memorystore.Provider.DeleteAllUserSessions(user.ID)
+		utils.RegisterEvent(ctx, constants.UserDeletedWebhookEvent, "", user)
+	}()
+
 	return res, nil
 }

server/resolvers/delete_webhook.go

@@ -0,0 +1,49 @@
+package resolvers
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/authorizerdev/authorizer/server/db"
+	"github.com/authorizerdev/authorizer/server/graph/model"
+	"github.com/authorizerdev/authorizer/server/token"
+	"github.com/authorizerdev/authorizer/server/utils"
+	log "github.com/sirupsen/logrus"
+)
+
+// DeleteWebhookResolver resolver to delete webhook and its relevant logs
+func DeleteWebhookResolver(ctx context.Context, params model.WebhookRequest) (*model.Response, error) {
+	gc, err := utils.GinContextFromContext(ctx)
+	if err != nil {
+		log.Debug("Failed to get GinContext: ", err)
+		return nil, err
+	}
+
+	if !token.IsSuperAdmin(gc) {
+		log.Debug("Not logged in as super admin")
+		return nil, fmt.Errorf("unauthorized")
+	}
+
+	if params.ID == "" {
+		log.Debug("webhookID is required")
+		return nil, fmt.Errorf("webhook ID required")
+	}
+
+	log := log.WithField("webhook_id", params.ID)
+
+	webhook, err := db.Provider.GetWebhookByID(ctx, params.ID)
+	if err != nil {
+		log.Debug("failed to get webhook: ", err)
+		return nil, err
+	}
+
+	err = db.Provider.DeleteWebhook(ctx, webhook)
+	if err != nil {
+		log.Debug("failed to delete webhook: ", err)
+		return nil, err
+	}
+
+	return &model.Response{
+		Message: "Webhook deleted successfully",
+	}, nil
+}

server/resolvers/email_templates.go

@@ -0,0 +1,35 @@
+package resolvers
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/authorizerdev/authorizer/server/db"
+	"github.com/authorizerdev/authorizer/server/graph/model"
+	"github.com/authorizerdev/authorizer/server/token"
+	"github.com/authorizerdev/authorizer/server/utils"
+	log "github.com/sirupsen/logrus"
+)
+
+// EmailTemplatesResolver resolver for getting the list of email templates based on pagination
+func EmailTemplatesResolver(ctx context.Context, params *model.PaginatedInput) (*model.EmailTemplates, error) {
+	gc, err := utils.GinContextFromContext(ctx)
+	if err != nil {
+		log.Debug("Failed to get GinContext: ", err)
+		return nil, err
+	}
+
+	if !token.IsSuperAdmin(gc) {
+		log.Debug("Not logged in as super admin")
+		return nil, fmt.Errorf("unauthorized")
+	}
+
+	pagination := utils.GetPagination(params)
+
+	emailTemplates, err := db.Provider.ListEmailTemplate(ctx, pagination)
+	if err != nil {
+		log.Debug("failed to get email templates: ", err)
+		return nil, err
+	}
+	return emailTemplates, nil
+}

server/resolvers/enable_access.go

@@ -6,6 +6,7 @@ import (
 
 	log "github.com/sirupsen/logrus"
 
+	"github.com/authorizerdev/authorizer/server/constants"
 	"github.com/authorizerdev/authorizer/server/db"
 	"github.com/authorizerdev/authorizer/server/graph/model"
 	"github.com/authorizerdev/authorizer/server/token"
@@ -31,7 +32,7 @@ func EnableAccessResolver(ctx context.Context, params model.UpdateAccessInput) (
 		"user_id": params.UserID,
 	})
 
-	user, err := db.Provider.GetUserByID(params.UserID)
+	user, err := db.Provider.GetUserByID(ctx, params.UserID)
 	if err != nil {
 		log.Debug("Failed to get user from DB: ", err)
 		return res, err
@@ -39,7 +40,7 @@ func EnableAccessResolver(ctx context.Context, params model.UpdateAccessInput) (
 
 	user.RevokedTimestamp = nil
 
-	user, err = db.Provider.UpdateUser(user)
+	user, err = db.Provider.UpdateUser(ctx, user)
 	if err != nil {
 		log.Debug("Failed to update user: ", err)
 		return res, err
@@ -49,5 +50,7 @@ func EnableAccessResolver(ctx context.Context, params model.UpdateAccessInput) (
 		Message: `user access enabled successfully`,
 	}
 
+	go utils.RegisterEvent(ctx, constants.UserAccessEnabledWebhookEvent, "", user)
+
 	return res, nil
 }

server/resolvers/env.go

@@ -10,6 +10,7 @@ import (
 	"github.com/authorizerdev/authorizer/server/constants"
 	"github.com/authorizerdev/authorizer/server/graph/model"
 	"github.com/authorizerdev/authorizer/server/memorystore"
+	"github.com/authorizerdev/authorizer/server/refs"
 	"github.com/authorizerdev/authorizer/server/token"
 	"github.com/authorizerdev/authorizer/server/utils"
 )
@@ -38,10 +39,10 @@ func EnvResolver(ctx context.Context) (*model.Env, error) {
 	}
 
 	if val, ok := store[constants.EnvKeyAccessTokenExpiryTime]; ok {
-		res.AccessTokenExpiryTime = utils.NewStringRef(val.(string))
+		res.AccessTokenExpiryTime = refs.NewStringRef(val.(string))
 	}
 	if val, ok := store[constants.EnvKeyAdminSecret]; ok {
-		res.AdminSecret = utils.NewStringRef(val.(string))
+		res.AdminSecret = refs.NewStringRef(val.(string))
 	}
 	if val, ok := store[constants.EnvKeyClientID]; ok {
 		res.ClientID = val.(string)
@@ -50,103 +51,103 @@ func EnvResolver(ctx context.Context) (*model.Env, error) {
 		res.ClientSecret = val.(string)
 	}
 	if val, ok := store[constants.EnvKeyDatabaseURL]; ok {
-		res.DatabaseURL = utils.NewStringRef(val.(string))
+		res.DatabaseURL = refs.NewStringRef(val.(string))
 	}
 	if val, ok := store[constants.EnvKeyDatabaseName]; ok {
-		res.DatabaseName = utils.NewStringRef(val.(string))
+		res.DatabaseName = refs.NewStringRef(val.(string))
 	}
 	if val, ok := store[constants.EnvKeyDatabaseType]; ok {
-		res.DatabaseType = utils.NewStringRef(val.(string))
+		res.DatabaseType = refs.NewStringRef(val.(string))
 	}
 	if val, ok := store[constants.EnvKeyDatabaseUsername]; ok {
-		res.DatabaseUsername = utils.NewStringRef(val.(string))
+		res.DatabaseUsername = refs.NewStringRef(val.(string))
 	}
 	if val, ok := store[constants.EnvKeyDatabasePassword]; ok {
-		res.DatabasePassword = utils.NewStringRef(val.(string))
+		res.DatabasePassword = refs.NewStringRef(val.(string))
 	}
 	if val, ok := store[constants.EnvKeyDatabaseHost]; ok {
-		res.DatabaseHost = utils.NewStringRef(val.(string))
+		res.DatabaseHost = refs.NewStringRef(val.(string))
 	}
 	if val, ok := store[constants.EnvKeyDatabasePort]; ok {
-		res.DatabasePort = utils.NewStringRef(val.(string))
+		res.DatabasePort = refs.NewStringRef(val.(string))
 	}
 	if val, ok := store[constants.EnvKeyCustomAccessTokenScript]; ok {
-		res.CustomAccessTokenScript = utils.NewStringRef(val.(string))
+		res.CustomAccessTokenScript = refs.NewStringRef(val.(string))
 	}
 	if val, ok := store[constants.EnvKeySmtpHost]; ok {
-		res.SMTPHost = utils.NewStringRef(val.(string))
+		res.SMTPHost = refs.NewStringRef(val.(string))
 	}
 	if val, ok := store[constants.EnvKeySmtpPort]; ok {
-		res.SMTPPort = utils.NewStringRef(val.(string))
+		res.SMTPPort = refs.NewStringRef(val.(string))
 	}
 	if val, ok := store[constants.EnvKeySmtpUsername]; ok {
-		res.SMTPUsername = utils.NewStringRef(val.(string))
+		res.SMTPUsername = refs.NewStringRef(val.(string))
 	}
 	if val, ok := store[constants.EnvKeySmtpPassword]; ok {
-		res.SMTPPassword = utils.NewStringRef(val.(string))
+		res.SMTPPassword = refs.NewStringRef(val.(string))
 	}
 	if val, ok := store[constants.EnvKeySenderEmail]; ok {
-		res.SenderEmail = utils.NewStringRef(val.(string))
+		res.SenderEmail = refs.NewStringRef(val.(string))
 	}
 	if val, ok := store[constants.EnvKeyJwtType]; ok {
-		res.JwtType = utils.NewStringRef(val.(string))
+		res.JwtType = refs.NewStringRef(val.(string))
 	}
 	if val, ok := store[constants.EnvKeyJwtSecret]; ok {
-		res.JwtSecret = utils.NewStringRef(val.(string))
+		res.JwtSecret = refs.NewStringRef(val.(string))
 	}
 	if val, ok := store[constants.EnvKeyJwtRoleClaim]; ok {
-		res.JwtRoleClaim = utils.NewStringRef(val.(string))
+		res.JwtRoleClaim = refs.NewStringRef(val.(string))
 	}
 	if val, ok := store[constants.EnvKeyJwtPublicKey]; ok {
-		res.JwtPublicKey = utils.NewStringRef(val.(string))
+		res.JwtPublicKey = refs.NewStringRef(val.(string))
 	}
 	if val, ok := store[constants.EnvKeyJwtPrivateKey]; ok {
-		res.JwtPrivateKey = utils.NewStringRef(val.(string))
+		res.JwtPrivateKey = refs.NewStringRef(val.(string))
 	}
 	if val, ok := store[constants.EnvKeyAppURL]; ok {
-		res.AppURL = utils.NewStringRef(val.(string))
+		res.AppURL = refs.NewStringRef(val.(string))
 	}
 	if val, ok := store[constants.EnvKeyRedisURL]; ok {
-		res.RedisURL = utils.NewStringRef(val.(string))
+		res.RedisURL = refs.NewStringRef(val.(string))
 	}
 	if val, ok := store[constants.EnvKeyResetPasswordURL]; ok {
-		res.ResetPasswordURL = utils.NewStringRef(val.(string))
+		res.ResetPasswordURL = refs.NewStringRef(val.(string))
 	}
 	if val, ok := store[constants.EnvKeyGoogleClientID]; ok {
-		res.GoogleClientID = utils.NewStringRef(val.(string))
+		res.GoogleClientID = refs.NewStringRef(val.(string))
 	}
 	if val, ok := store[constants.EnvKeyGoogleClientSecret]; ok {
-		res.GoogleClientSecret = utils.NewStringRef(val.(string))
+		res.GoogleClientSecret = refs.NewStringRef(val.(string))
 	}
 	if val, ok := store[constants.EnvKeyFacebookClientID]; ok {
-		res.FacebookClientID = utils.NewStringRef(val.(string))
+		res.FacebookClientID = refs.NewStringRef(val.(string))
 	}
 	if val, ok := store[constants.EnvKeyFacebookClientSecret]; ok {
-		res.FacebookClientSecret = utils.NewStringRef(val.(string))
+		res.FacebookClientSecret = refs.NewStringRef(val.(string))
 	}
 	if val, ok := store[constants.EnvKeyGithubClientID]; ok {
-		res.GithubClientID = utils.NewStringRef(val.(string))
+		res.GithubClientID = refs.NewStringRef(val.(string))
 	}
 	if val, ok := store[constants.EnvKeyGithubClientSecret]; ok {
-		res.GithubClientSecret = utils.NewStringRef(val.(string))
+		res.GithubClientSecret = refs.NewStringRef(val.(string))
 	}
 	if val, ok := store[constants.EnvKeyLinkedInClientID]; ok {
-		res.LinkedinClientID = utils.NewStringRef(val.(string))
+		res.LinkedinClientID = refs.NewStringRef(val.(string))
 	}
 	if val, ok := store[constants.EnvKeyLinkedInClientSecret]; ok {
-		res.LinkedinClientSecret = utils.NewStringRef(val.(string))
+		res.LinkedinClientSecret = refs.NewStringRef(val.(string))
 	}
 	if val, ok := store[constants.EnvKeyAppleClientID]; ok {
-		res.AppleClientID = utils.NewStringRef(val.(string))
+		res.AppleClientID = refs.NewStringRef(val.(string))
 	}
 	if val, ok := store[constants.EnvKeyAppleClientSecret]; ok {
-		res.AppleClientSecret = utils.NewStringRef(val.(string))
+		res.AppleClientSecret = refs.NewStringRef(val.(string))
 	}
 	if val, ok := store[constants.EnvKeyOrganizationName]; ok {
-		res.OrganizationName = utils.NewStringRef(val.(string))
+		res.OrganizationName = refs.NewStringRef(val.(string))
 	}
 	if val, ok := store[constants.EnvKeyOrganizationLogo]; ok {
-		res.OrganizationLogo = utils.NewStringRef(val.(string))
+		res.OrganizationLogo = refs.NewStringRef(val.(string))
 	}
 
 	// string slice vars
@@ -168,6 +169,7 @@ func EnvResolver(ctx context.Context) (*model.Env, error) {
 	res.DisableMagicLinkLogin = store[constants.EnvKeyDisableMagicLinkLogin].(bool)
 	res.DisableLoginPage = store[constants.EnvKeyDisableLoginPage].(bool)
 	res.DisableSignUp = store[constants.EnvKeyDisableSignUp].(bool)
+	res.DisableStrongPassword = store[constants.EnvKeyDisableStrongPassword].(bool)
 
 	return res, nil
 }

server/resolvers/forgot_password.go

@@ -49,7 +49,7 @@ func ForgotPasswordResolver(ctx context.Context, params model.ForgotPasswordInpu
 	log := log.WithFields(log.Fields{
 		"email": params.Email,
 	})
-	_, err = db.Provider.GetUserByEmail(params.Email)
+	_, err = db.Provider.GetUserByEmail(ctx, params.Email)
 	if err != nil {
 		log.Debug("User not found: ", err)
 		return res, fmt.Errorf(`user with this email not found`)
@@ -71,7 +71,7 @@ func ForgotPasswordResolver(ctx context.Context, params model.ForgotPasswordInpu
 		log.Debug("Failed to create verification token", err)
 		return res, err
 	}
-	_, err = db.Provider.AddVerificationRequest(models.VerificationRequest{
+	_, err = db.Provider.AddVerificationRequest(ctx, models.VerificationRequest{
 		Token:       verificationToken,
 		Identifier:  constants.VerificationTypeForgotPassword,
 		ExpiresAt:   time.Now().Add(time.Minute * 30).Unix(),

server/resolvers/invite_members.go

@@ -70,7 +70,7 @@ func InviteMembersResolver(ctx context.Context, params model.InviteMemberInput)
 	// for each emails check if emails exists in db
 	newEmails := []string{}
 	for _, email := range emails {
-		_, err := db.Provider.GetUserByEmail(email)
+		_, err := db.Provider.GetUserByEmail(ctx, email)
 		if err != nil {
 			log.Debugf("User with %s email not found, so inviting user", email)
 			newEmails = append(newEmails, email)
@@ -129,24 +129,24 @@ func InviteMembersResolver(ctx context.Context, params model.InviteMemberInput)
 
 		// use magic link login if that option is on
 		if !isMagicLinkLoginDisabled {
-			user.SignupMethods = constants.SignupMethodMagicLinkLogin
+			user.SignupMethods = constants.AuthRecipeMethodMagicLinkLogin
 			verificationRequest.Identifier = constants.VerificationTypeMagicLinkLogin
 		} else {
 			// use basic authentication if that option is on
-			user.SignupMethods = constants.SignupMethodBasicAuth
+			user.SignupMethods = constants.AuthRecipeMethodBasicAuth
 			verificationRequest.Identifier = constants.VerificationTypeForgotPassword
 
 			verifyEmailURL = appURL + "/setup-password"
 
 		}
 
-		user, err = db.Provider.AddUser(user)
+		user, err = db.Provider.AddUser(ctx, user)
 		if err != nil {
 			log.Debugf("Error adding user: %s, err: %v", email, err)
 			return nil, err
 		}
 
-		_, err = db.Provider.AddVerificationRequest(verificationRequest)
+		_, err = db.Provider.AddVerificationRequest(ctx, verificationRequest)
 		if err != nil {
 			log.Debugf("Error adding verification request: %s, err: %v", email, err)
 			return nil, err

server/resolvers/login.go

@@ -45,7 +45,7 @@ func LoginResolver(ctx context.Context, params model.LoginInput) (*model.AuthRes
 		"email": params.Email,
 	})
 	params.Email = strings.ToLower(params.Email)
-	user, err := db.Provider.GetUserByEmail(params.Email)
+	user, err := db.Provider.GetUserByEmail(ctx, params.Email)
 	if err != nil {
 		log.Debug("Failed to get user by email: ", err)
 		return res, fmt.Errorf(`user with this email not found`)
@@ -56,7 +56,7 @@ func LoginResolver(ctx context.Context, params model.LoginInput) (*model.AuthRes
 		return res, fmt.Errorf(`user access has been revoked`)
 	}
 
-	if !strings.Contains(user.SignupMethods, constants.SignupMethodBasicAuth) {
+	if !strings.Contains(user.SignupMethods, constants.AuthRecipeMethodBasicAuth) {
 		log.Debug("User signup method is not basic auth")
 		return res, fmt.Errorf(`user has not signed up email & password`)
 	}
@@ -97,7 +97,7 @@ func LoginResolver(ctx context.Context, params model.LoginInput) (*model.AuthRes
 		scope = params.Scope
 	}
 
-	authToken, err := token.CreateAuthToken(gc, user, roles, scope)
+	authToken, err := token.CreateAuthToken(gc, user, roles, scope, constants.AuthRecipeMethodBasicAuth)
 	if err != nil {
 		log.Debug("Failed to create auth token", err)
 		return res, err
@@ -117,19 +117,23 @@ func LoginResolver(ctx context.Context, params model.LoginInput) (*model.AuthRes
 	}
 
 	cookie.SetSession(gc, authToken.FingerPrintHash)
-	memorystore.Provider.SetUserSession(user.ID, constants.TokenTypeSessionToken+"_"+authToken.FingerPrint, authToken.FingerPrintHash)
+	sessionStoreKey := constants.AuthRecipeMethodBasicAuth + ":" + user.ID
-	memorystore.Provider.SetUserSession(user.ID, constants.TokenTypeAccessToken+"_"+authToken.FingerPrint, authToken.AccessToken.Token)
+	memorystore.Provider.SetUserSession(sessionStoreKey, constants.TokenTypeSessionToken+"_"+authToken.FingerPrint, authToken.FingerPrintHash)
+	memorystore.Provider.SetUserSession(sessionStoreKey, constants.TokenTypeAccessToken+"_"+authToken.FingerPrint, authToken.AccessToken.Token)
 
 	if authToken.RefreshToken != nil {
 		res.RefreshToken = &authToken.RefreshToken.Token
-		memorystore.Provider.SetUserSession(user.ID, constants.TokenTypeRefreshToken+"_"+authToken.FingerPrint, authToken.RefreshToken.Token)
+		memorystore.Provider.SetUserSession(sessionStoreKey, constants.TokenTypeRefreshToken+"_"+authToken.FingerPrint, authToken.RefreshToken.Token)
 	}
 
-	go db.Provider.AddSession(models.Session{
+	go func() {
-		UserID:    user.ID,
+		utils.RegisterEvent(ctx, constants.UserLoginWebhookEvent, constants.AuthRecipeMethodBasicAuth, user)
-		UserAgent: utils.GetUserAgent(gc.Request),
+		db.Provider.AddSession(ctx, models.Session{
-		IP:        utils.GetIP(gc.Request),
+			UserID:    user.ID,
-	})
+			UserAgent: utils.GetUserAgent(gc.Request),
+			IP:        utils.GetIP(gc.Request),
+		})
+	}()
 
 	return res, nil
 }

server/resolvers/logout.go

@@ -41,7 +41,12 @@ func LogoutResolver(ctx context.Context) (*model.Response, error) {
 		return nil, err
 	}
 
-	memorystore.Provider.DeleteUserSession(sessionData.Subject, sessionData.Nonce)
+	sessionKey := sessionData.Subject
+	if sessionData.LoginMethod != "" {
+		sessionKey = sessionData.LoginMethod + ":" + sessionData.Subject
+	}
+
+	memorystore.Provider.DeleteUserSession(sessionKey, sessionData.Nonce)
 	cookie.DeleteSession(gc)
 
 	res := &model.Response{

server/resolvers/magic_link_login.go

@@ -59,7 +59,7 @@ func MagicLinkLoginResolver(ctx context.Context, params model.MagicLinkLoginInpu
 	}
 
 	// find user with email
-	existingUser, err := db.Provider.GetUserByEmail(params.Email)
+	existingUser, err := db.Provider.GetUserByEmail(ctx, params.Email)
 	if err != nil {
 		isSignupDisabled, err := memorystore.Provider.GetBoolStoreEnvVariable(constants.EnvKeyDisableSignUp)
 		if err != nil {
@@ -70,7 +70,7 @@ func MagicLinkLoginResolver(ctx context.Context, params model.MagicLinkLoginInpu
 			return res, fmt.Errorf(`signup is disabled for this instance`)
 		}
 
-		user.SignupMethods = constants.SignupMethodMagicLinkLogin
+		user.SignupMethods = constants.AuthRecipeMethodMagicLinkLogin
 		// define roles for new user
 		if len(params.Roles) > 0 {
 			// check if roles exists
@@ -99,7 +99,8 @@ func MagicLinkLoginResolver(ctx context.Context, params model.MagicLinkLoginInpu
 		}
 
 		user.Roles = strings.Join(inputRoles, ",")
-		user, _ = db.Provider.AddUser(user)
+		user, _ = db.Provider.AddUser(ctx, user)
+		go utils.RegisterEvent(ctx, constants.UserCreatedWebhookEvent, constants.AuthRecipeMethodMagicLinkLogin, user)
 	} else {
 		user = existingUser
 		// There multiple scenarios with roles here in magic link login
@@ -158,12 +159,12 @@ func MagicLinkLoginResolver(ctx context.Context, params model.MagicLinkLoginInpu
 		}
 
 		signupMethod := existingUser.SignupMethods
-		if !strings.Contains(signupMethod, constants.SignupMethodMagicLinkLogin) {
+		if !strings.Contains(signupMethod, constants.AuthRecipeMethodMagicLinkLogin) {
-			signupMethod = signupMethod + "," + constants.SignupMethodMagicLinkLogin
+			signupMethod = signupMethod + "," + constants.AuthRecipeMethodMagicLinkLogin
 		}
 
 		user.SignupMethods = signupMethod
-		user, _ = db.Provider.UpdateUser(user)
+		user, _ = db.Provider.UpdateUser(ctx, user)
 		if err != nil {
 			log.Debug("Failed to update user: ", err)
 		}
@@ -205,7 +206,7 @@ func MagicLinkLoginResolver(ctx context.Context, params model.MagicLinkLoginInpu
 		if err != nil {
 			log.Debug("Failed to create verification token: ", err)
 		}
-		_, err = db.Provider.AddVerificationRequest(models.VerificationRequest{
+		_, err = db.Provider.AddVerificationRequest(ctx, models.VerificationRequest{
 			Token:       verificationToken,
 			Identifier:  verificationType,
 			ExpiresAt:   time.Now().Add(time.Minute * 30).Unix(),