feat: add database methods for webhookLog

server/db/models/model.go

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

server/db/models/webhook_log.go

@@ -1,15 +1,31 @@
 package models
 
+import "github.com/authorizerdev/authorizer/server/graph/model"
+
 // 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 int32  `json:"http_status" bson:"http_status" cql:"http_status"`
+	HttpStatus int64  `json:"http_status" bson:"http_status" cql:"http_status"`
 	Response   string `json:"response" bson:"response" cql:"response"`
 	Request    string `json:"request" bson:"request" cql:"request"`
 	WebhookID  string `gorm:"type:char(36),index:" 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"`
 }
+
+func (w *WebhookLog) AsAPIWebhookLog() *model.WebhookLog {
+	createdAt := w.CreatedAt
+	updatedAt := w.UpdatedAt
+	return &model.WebhookLog{
+		ID:         w.ID,
+		HTTPStatus: &w.HttpStatus,
+		Response:   &w.Response,
+		Request:    &w.Request,
+		WebhookID:  &w.WebhookID,
+		CreatedAt:  &createdAt,
+		UpdatedAt:  &updatedAt,
+	}
+}

server/db/providers/arangodb/provider.go

@@ -107,6 +107,33 @@ 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{
+		Unique: true,
+	})
+
 	return &provider{
 		db: arangodb,
 	}, err

server/db/providers/arangodb/webhook.go

@@ -1,17 +1,28 @@
 package arangodb
 
 import (
+	"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(webhook models.Webhook) (models.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, nil
 }
 
 // UpdateWebhook to update webhook
 func (p *provider) UpdateWebhook(webhook models.Webhook) (models.Webhook, error) {
+	webhook.UpdatedAt = time.Now().Unix()
 	return webhook, nil
 }
 

server/db/providers/arangodb/webhook_log.go

@@ -1,16 +1,74 @@
 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(webhookLog models.WebhookLog) (models.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(nil, models.Collections.WebhookLog)
+	_, err := webhookLogCollection.CreateDocument(nil, webhookLog)
+	if err != nil {
+		return webhookLog, err
+	}
 	return webhookLog, nil
 }
 
 // ListWebhookLogs to list webhook logs
-func (p *provider) ListWebhookLogs(req model.ListWebhookLogRequest) (*model.WebhookLogs, error) {
-	return nil, nil
+func (p *provider) ListWebhookLogs(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 == @webhookID SORT d.created_at DESC LIMIT %d, %d RETURN d", models.Collections.WebhookLog, pagination.Offset, pagination.Limit)
+		bindVariables = map[string]interface{}{
+			webhookID: webhookID,
+		}
+	}
+	ctx := driver.WithQueryFullCount(context.Background())
+	cursor, err := p.db.Query(ctx, 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(nil, &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/provider.go

@@ -177,6 +177,28 @@ 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, 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
+	}
+
 	return &provider{
 		db: session,
 	}, err

server/db/providers/cassandradb/webhook.go

@@ -1,17 +1,28 @@
 package cassandradb
 
 import (
+	"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(webhook models.Webhook) (models.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, nil
 }
 
 // UpdateWebhook to update webhook
 func (p *provider) UpdateWebhook(webhook models.Webhook) (models.Webhook, error) {
+	webhook.UpdatedAt = time.Now().Unix()
 	return webhook, nil
 }
 

server/db/providers/cassandradb/webhook_log.go

@@ -1,16 +1,69 @@
 package cassandradb
 
 import (
+	"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(webhookLog models.WebhookLog) (models.WebhookLog, error) {
+	if webhookLog.ID == "" {
+		webhookLog.ID = uuid.New().String()
+	}
+
+	webhookLog.Key = webhookLog.ID
+	webhookLog.CreatedAt = time.Now().Unix()
+	webhookLog.UpdatedAt = time.Now().Unix()
+
+	insertWebhookLogQuery := 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(insertWebhookLogQuery).Exec()
+	if err != nil {
+		return webhookLog, err
+	}
 	return webhookLog, nil
 }
 
 // ListWebhookLogs to list webhook logs
-func (p *provider) ListWebhookLogs(req model.ListWebhookLogRequest) (*model.WebhookLogs, error) {
-	return nil, nil
+func (p *provider) ListWebhookLogs(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'`, 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", 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/provider.go

@@ -83,6 +83,24 @@ 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())
+
 	return &provider{
 		db: mongodb,
 	}, nil

server/db/providers/mongodb/webhook.go

@@ -1,17 +1,28 @@
 package mongodb
 
 import (
+	"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(webhook models.Webhook) (models.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, nil
 }
 
 // UpdateWebhook to update webhook
 func (p *provider) UpdateWebhook(webhook models.Webhook) (models.Webhook, error) {
+	webhook.UpdatedAt = time.Now().Unix()
 	return webhook, nil
 }
 

server/db/providers/mongodb/webhook_log.go

@@ -1,16 +1,72 @@
 package mongodb
 
 import (
+	"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(webhookLog models.WebhookLog) (models.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(nil, webhookLog)
+	if err != nil {
+		return webhookLog, err
+	}
 	return webhookLog, nil
 }
 
 // ListWebhookLogs to list webhook logs
-func (p *provider) ListWebhookLogs(req model.ListWebhookLogRequest) (*model.WebhookLogs, error) {
-	return nil, nil
+func (p *provider) ListWebhookLogs(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(nil, query, options.Count())
+	if err != nil {
+		return nil, err
+	}
+
+	paginationClone.Total = count
+
+	cursor, err := webhookLogCollection.Find(nil, query, opts)
+	if err != nil {
+		return nil, err
+	}
+
+	for cursor.Next(nil) {
+		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/webhook.go

@@ -1,17 +1,28 @@
 package provider_template
 
 import (
+	"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(webhook models.Webhook) (models.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, nil
 }
 
 // UpdateWebhook to update webhook
 func (p *provider) UpdateWebhook(webhook models.Webhook) (models.Webhook, error) {
+	webhook.UpdatedAt = time.Now().Unix()
 	return webhook, nil
 }
 

server/db/providers/provider_template/webhook_log.go

@@ -1,16 +1,26 @@
 package provider_template
 
 import (
+	"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(webhookLog models.WebhookLog) (models.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, nil
 }
 
 // ListWebhookLogs to list webhook logs
-func (p *provider) ListWebhookLogs(req model.ListWebhookLogRequest) (*model.WebhookLogs, error) {
+func (p *provider) ListWebhookLogs(pagination model.Pagination, webhookID string) (*model.WebhookLogs, error) {
 	return nil, nil
 }

server/db/providers/providers.go

@@ -58,5 +58,5 @@ type Provider interface {
 	// AddWebhookLog to add webhook log
 	AddWebhookLog(webhookLog models.WebhookLog) (models.WebhookLog, error)
 	// ListWebhookLogs to list webhook logs
-	ListWebhookLogs(req model.ListWebhookLogRequest) (*model.WebhookLogs, error)
+	ListWebhookLogs(pagination model.Pagination, webhookID string) (*model.WebhookLogs, error)
 }

server/db/providers/sql/provider.go

@@ -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{})
 	if err != nil {
 		return nil, err
 	}

server/db/providers/sql/webhook.go

@@ -1,17 +1,28 @@
 package sql
 
 import (
+	"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(webhook models.Webhook) (models.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, nil
 }
 
 // UpdateWebhook to update webhook
 func (p *provider) UpdateWebhook(webhook models.Webhook) (models.Webhook, error) {
+	webhook.UpdatedAt = time.Now().Unix()
 	return webhook, nil
 }
 

server/db/providers/sql/webhook_log.go

@@ -1,16 +1,67 @@
 package sql
 
 import (
+	"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(webhookLog models.WebhookLog) (models.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 webhookLog, res.Error
+	}
+
 	return webhookLog, nil
 }
 
 // ListWebhookLogs to list webhook logs
-func (p *provider) ListWebhookLogs(req model.ListWebhookLogRequest) (*model.WebhookLogs, error) {
-	return nil, nil
+func (p *provider) ListWebhookLogs(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
 }