Redesign trust center console

Signed-off-by: Sacha Al Himdani <sacha@getprobo.com>

pkg/coredata/migrations/20251024T183816Z.sql

@@ -0,0 +1,10 @@
+ALTER TABLE trust_center_accesses
+ADD COLUMN last_token_expires_at TIMESTAMP WITH TIME ZONE;
+
+UPDATE trust_center_accesses
+SET last_token_expires_at = created_at + INTERVAL '7 days'
+WHERE active = true AND last_token_expires_at IS NULL;
+
+ALTER TABLE trust_center_document_accesses ADD COLUMN requested BOOLEAN NOT NULL DEFAULT false;
+UPDATE trust_center_document_accesses SET requested = true WHERE active = false;
+ALTER TABLE trust_center_document_accesses ALTER COLUMN requested DROP DEFAULT;

pkg/coredata/trust_center_access.go

@@ -41,6 +41,7 @@ type (
 		NDAFileID                                 *gid.GID        `db:"nda_file_id"`
 		CreatedAt                                 time.Time       `db:"created_at"`
 		UpdatedAt                                 time.Time       `db:"updated_at"`
+		LastTokenExpiresAt                        *time.Time      `db:"last_token_expires_at"`
 	}
 
 	TrustCenterAccesses []*TrustCenterAccess
@@ -81,7 +82,8 @@ SELECT
 	has_accepted_non_disclosure_agreement_metadata,
 	nda_file_id,
 	created_at,
-	updated_at
+	updated_at,
+	last_token_expires_at
 FROM
 	trust_center_accesses
 WHERE
@@ -133,7 +135,8 @@ SELECT
 	has_accepted_non_disclosure_agreement_metadata,
 	nda_file_id,
 	created_at,
-	updated_at
+	updated_at,
+	last_token_expires_at
 FROM
 	trust_center_accesses
 WHERE
@@ -231,7 +234,8 @@ UPDATE trust_center_accesses SET
 	updated_at = @updated_at,
 	has_accepted_non_disclosure_agreement = @has_accepted_non_disclosure_agreement,
 	has_accepted_non_disclosure_agreement_metadata = @has_accepted_non_disclosure_agreement_metadata,
-	nda_file_id = @nda_file_id
+	nda_file_id = @nda_file_id,
+	last_token_expires_at = @last_token_expires_at
 WHERE
 	%s
 	AND id = @id
@@ -246,7 +250,8 @@ WHERE
 		"updated_at":                            tca.UpdatedAt,
 		"has_accepted_non_disclosure_agreement": tca.HasAcceptedNonDisclosureAgreement,
 		"has_accepted_non_disclosure_agreement_metadata": tca.HasAcceptedNonDisclosureAgreementMetadata,
-		"nda_file_id": tca.NDAFileID,
+		"nda_file_id":           tca.NDAFileID,
+		"last_token_expires_at": tca.LastTokenExpiresAt,
 	}
 	maps.Copy(args, scope.SQLArguments())
 
@@ -304,7 +309,8 @@ SELECT
 	has_accepted_non_disclosure_agreement_metadata,
 	nda_file_id,
 	created_at,
-	updated_at
+	updated_at,
+	last_token_expires_at
 FROM
 	trust_center_accesses
 WHERE

pkg/coredata/trust_center_document_access.go

@@ -16,6 +16,7 @@ package coredata
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"maps"
 	"time"
@@ -34,13 +35,22 @@ type (
 		ReportID            *gid.GID  `db:"report_id"`
 		TrustCenterFileID   *gid.GID  `db:"trust_center_file_id"`
 		Active              bool      `db:"active"`
+		Requested           bool      `db:"requested"`
 		CreatedAt           time.Time `db:"created_at"`
 		UpdatedAt           time.Time `db:"updated_at"`
 	}
 
 	TrustCenterDocumentAccesses []*TrustCenterDocumentAccess
+
+	ErrTrustCenterDocumentAccessNotFound struct {
+		Identifier string
+	}
 )
 
+func (e ErrTrustCenterDocumentAccessNotFound) Error() string {
+	return fmt.Sprintf("trust center document access not found: %s", e.Identifier)
+}
+
 func (tcda *TrustCenterDocumentAccess) CursorKey(orderBy TrustCenterDocumentAccessOrderField) page.CursorKey {
 	switch orderBy {
 	case TrustCenterDocumentAccessOrderFieldCreatedAt:
@@ -64,6 +74,7 @@ SELECT
 	report_id,
 	trust_center_file_id,
 	active,
+	requested,
 	created_at,
 	updated_at
 FROM
@@ -86,6 +97,9 @@ LIMIT 1;
 
 	access, err := pgx.CollectExactlyOneRow(rows, pgx.RowToStructByName[TrustCenterDocumentAccess])
 	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return &ErrTrustCenterDocumentAccessNotFound{Identifier: accessID.String()}
+		}
 		return fmt.Errorf("cannot collect trust center document access: %w", err)
 	}
 
@@ -109,6 +123,7 @@ SELECT
 	report_id,
 	trust_center_file_id,
 	active,
+	requested,
 	created_at,
 	updated_at
 FROM
@@ -158,6 +173,7 @@ SELECT
 	report_id,
 	trust_center_file_id,
 	active,
+	requested,
 	created_at,
 	updated_at
 FROM
@@ -206,6 +222,7 @@ INSERT INTO trust_center_document_accesses (
 	report_id,
 	trust_center_file_id,
 	active,
+	requested,
 	created_at,
 	updated_at
 ) VALUES (
@@ -216,6 +233,7 @@ INSERT INTO trust_center_document_accesses (
 	@report_id,
 	@trust_center_file_id,
 	@active,
+	@requested,
 	@created_at,
 	@updated_at
 )
@@ -229,6 +247,7 @@ INSERT INTO trust_center_document_accesses (
 		"report_id":              tcda.ReportID,
 		"trust_center_file_id":   tcda.TrustCenterFileID,
 		"active":                 tcda.Active,
+		"requested":              tcda.Requested,
 		"created_at":             tcda.CreatedAt,
 		"updated_at":             tcda.UpdatedAt,
 	}
@@ -332,7 +351,76 @@ WHERE
 	return count, nil
 }
 
-func (tcdas *TrustCenterDocumentAccesses) LoadByTrustCenterAccessID(
+func (tcdas *TrustCenterDocumentAccesses) CountPendingRequestByTrustCenterAccessID(
+	ctx context.Context,
+	conn pg.Conn,
+	scope Scoper,
+	trustCenterAccessID gid.GID,
+) (int, error) {
+	q := `
+SELECT
+	COUNT(id)
+FROM
+	trust_center_document_accesses
+WHERE
+	%s
+	AND trust_center_access_id = @trust_center_access_id
+	AND requested = true
+	AND active = false
+`
+
+	q = fmt.Sprintf(q, scope.SQLFragment())
+
+	args := pgx.StrictNamedArgs{
+		"trust_center_access_id": trustCenterAccessID,
+	}
+	maps.Copy(args, scope.SQLArguments())
+
+	row := conn.QueryRow(ctx, q, args)
+
+	var count int
+	if err := row.Scan(&count); err != nil {
+		return 0, fmt.Errorf("cannot scan count: %w", err)
+	}
+
+	return count, nil
+}
+
+func (tcdas *TrustCenterDocumentAccesses) CountActiveByTrustCenterAccessID(
+	ctx context.Context,
+	conn pg.Conn,
+	scope Scoper,
+	trustCenterAccessID gid.GID,
+) (int, error) {
+	q := `
+SELECT
+	COUNT(id)
+FROM
+	trust_center_document_accesses
+WHERE
+	%s
+	AND trust_center_access_id = @trust_center_access_id
+	AND active = true
+`
+
+	q = fmt.Sprintf(q, scope.SQLFragment())
+
+	args := pgx.StrictNamedArgs{
+		"trust_center_access_id": trustCenterAccessID,
+	}
+	maps.Copy(args, scope.SQLArguments())
+
+	row := conn.QueryRow(ctx, q, args)
+
+	var count int
+	if err := row.Scan(&count); err != nil {
+		return 0, fmt.Errorf("cannot scan count: %w", err)
+	}
+
+	return count, nil
+}
+
+func (tcdas *TrustCenterDocumentAccesses) LoadAvailableByTrustCenterAccessID(
 	ctx context.Context,
 	conn pg.Conn,
 	scope Scoper,
@@ -340,6 +428,79 @@ func (tcdas *TrustCenterDocumentAccesses) LoadByTrustCenterAccessID(
 	cursor *page.Cursor[TrustCenterDocumentAccessOrderField],
 ) error {
 	q := `
+WITH organization AS (
+	SELECT tc.organization_id
+	FROM trust_center_accesses tca
+	INNER JOIN trust_centers tc ON tca.trust_center_id = tc.id
+	WHERE tca.tenant_id = @tenant_id
+		AND tca.id = @trust_center_access_id
+),
+tenant_organization AS (
+	SELECT o.id AS organization_id
+	FROM organizations o
+	WHERE %s
+),
+all_items AS (
+	SELECT
+		d.id AS item_id,
+		d.id AS document_id,
+		NULL::text AS report_id,
+		NULL::text AS trust_center_file_id,
+		d.created_at AS item_created_at,
+		d.updated_at AS item_updated_at
+	FROM documents d, tenant_organization o
+	WHERE d.organization_id = o.organization_id
+		AND d.deleted_at IS NULL
+		AND d.trust_center_visibility = 'PRIVATE'::trust_center_visibility
+
+	UNION ALL
+
+	SELECT
+		r.id AS item_id,
+		NULL::text AS document_id,
+		r.id AS report_id,
+		NULL::text AS trust_center_file_id,
+		r.created_at AS item_created_at,
+		r.updated_at AS item_updated_at
+	FROM audits r, tenant_organization o
+	WHERE r.organization_id = o.organization_id
+		AND r.trust_center_visibility = 'PRIVATE'::trust_center_visibility
+
+	UNION ALL
+
+	SELECT
+		tcf.id AS item_id,
+		NULL::text AS document_id,
+		NULL::text AS report_id,
+		tcf.id AS trust_center_file_id,
+		tcf.created_at AS item_created_at,
+		tcf.updated_at AS item_updated_at
+	FROM trust_center_files tcf, tenant_organization o
+	WHERE tcf.organization_id = o.organization_id
+		AND tcf.trust_center_visibility = 'PRIVATE'::trust_center_visibility
+),
+final_items AS (
+	SELECT
+		COALESCE(tcda.id, ai.item_id) AS id,
+		tcda.tenant_id,
+		@trust_center_access_id AS trust_center_access_id,
+		ai.document_id,
+		ai.report_id,
+		ai.trust_center_file_id,
+		COALESCE(tcda.active, false) AS active,
+		COALESCE(tcda.requested, false) AS requested,
+		COALESCE(tcda.created_at, ai.item_created_at) AS created_at,
+		COALESCE(tcda.updated_at, ai.item_updated_at) AS updated_at
+	FROM all_items ai
+	LEFT JOIN trust_center_document_accesses tcda ON (
+		tcda.trust_center_access_id = @trust_center_access_id
+		AND (
+			(tcda.document_id = ai.document_id AND ai.document_id IS NOT NULL)
+			OR (tcda.report_id = ai.report_id AND ai.report_id IS NOT NULL)
+			OR (tcda.trust_center_file_id = ai.trust_center_file_id AND ai.trust_center_file_id IS NOT NULL)
+		)
+	)
+)
 SELECT
 	id,
 	trust_center_access_id,
@@ -347,14 +508,11 @@ SELECT
 	report_id,
 	trust_center_file_id,
 	active,
+	requested,
 	created_at,
 	updated_at
-FROM
-	trust_center_document_accesses
-WHERE
-	%s
-	AND trust_center_access_id = @trust_center_access_id
-	AND %s
+FROM final_items
+WHERE %s
 `
 
 	q = fmt.Sprintf(q, scope.SQLFragment(), cursor.SQLFragment())
@@ -394,6 +552,7 @@ SELECT
 	report_id,
 	trust_center_file_id,
 	active,
+	requested,
 	created_at,
 	updated_at
 FROM
@@ -464,10 +623,6 @@ func ActivateByDocumentIDs(
 	documentIDs []gid.GID,
 	updatedAt time.Time,
 ) error {
-	if len(documentIDs) == 0 {
-		return nil
-	}
-
 	q := `
 UPDATE trust_center_document_accesses
 SET active = true, updated_at = @updated_at
@@ -502,10 +657,6 @@ func ActivateByReportIDs(
 	reportIDs []gid.GID,
 	updatedAt time.Time,
 ) error {
-	if len(reportIDs) == 0 {
-		return nil
-	}
-
 	q := `
 UPDATE trust_center_document_accesses
 SET active = true, updated_at = @updated_at
@@ -538,6 +689,7 @@ func (tcdas TrustCenterDocumentAccesses) BulkInsertDocumentAccesses(
 	scope Scoper,
 	trustCenterAccessID gid.GID,
 	documentIDs []gid.GID,
+	requested bool,
 	createdAt time.Time,
 ) error {
 	if len(documentIDs) == 0 {
@@ -554,13 +706,15 @@ WITH document_access_data AS (
 		null::text AS report_id,
 		null::text AS trust_center_file_id,
 		false AS active,
+		@requested::boolean AS requested,
 		@created_at::timestamptz AS created_at,
 		@updated_at::timestamptz AS updated_at
 )
 INSERT INTO trust_center_document_accesses (
-	id, tenant_id, trust_center_access_id, document_id, report_id, trust_center_file_id, active, created_at, updated_at
+	id, tenant_id, trust_center_access_id, document_id, report_id, trust_center_file_id, active, requested, created_at, updated_at
 )
 SELECT * FROM document_access_data
+ON CONFLICT DO NOTHING
 `
 
 	args := pgx.StrictNamedArgs{
@@ -568,6 +722,7 @@ SELECT * FROM document_access_data
 		"trust_center_access_id": trustCenterAccessID,
 		"document_ids":           documentIDs,
 		"trust_center_document_access_entity_type": TrustCenterDocumentAccessEntityType,
+		"requested":  requested,
 		"created_at": createdAt,
 		"updated_at": createdAt,
 	}
@@ -585,6 +740,7 @@ func (tcdas TrustCenterDocumentAccesses) BulkInsertReportAccesses(
 	scope Scoper,
 	trustCenterAccessID gid.GID,
 	reportIDs []gid.GID,
+	requested bool,
 	createdAt time.Time,
 ) error {
 	if len(reportIDs) == 0 {
@@ -601,13 +757,15 @@ WITH report_access_data AS (
 		unnest(@report_ids::text[]) AS report_id,
 		null::text AS trust_center_file_id,
 		false AS active,
+		@requested::boolean AS requested,
 		@created_at::timestamptz AS created_at,
 		@updated_at::timestamptz AS updated_at
 )
 INSERT INTO trust_center_document_accesses (
-	id, tenant_id, trust_center_access_id, document_id, report_id, trust_center_file_id, active, created_at, updated_at
+	id, tenant_id, trust_center_access_id, document_id, report_id, trust_center_file_id, active, requested, created_at, updated_at
 )
 SELECT * FROM report_access_data
+ON CONFLICT DO NOTHING
 `
 
 	args := pgx.StrictNamedArgs{
@@ -641,6 +799,7 @@ SELECT
 	report_id,
 	trust_center_file_id,
 	active,
+	requested,
 	created_at,
 	updated_at
 FROM
@@ -715,6 +874,7 @@ func (tcdas TrustCenterDocumentAccesses) BulkInsertTrustCenterFileAccesses(
 	scope Scoper,
 	trustCenterAccessID gid.GID,
 	trustCenterFileIDs []gid.GID,
+	requested bool,
 	createdAt time.Time,
 ) error {
 	q := `
@@ -727,13 +887,15 @@ WITH trust_center_file_access_data AS (
 		null::text AS report_id,
 		unnest(@trust_center_file_ids::text[]) AS trust_center_file_id,
 		false AS active,
+		@requested::boolean AS requested,
 		@created_at::timestamptz AS created_at,
 		@updated_at::timestamptz AS updated_at
 )
 INSERT INTO trust_center_document_accesses (
-	id, tenant_id, trust_center_access_id, document_id, report_id, trust_center_file_id, active, created_at, updated_at
+	id, tenant_id, trust_center_access_id, document_id, report_id, trust_center_file_id, active, requested, created_at, updated_at
 )
 SELECT * FROM trust_center_file_access_data
+ON CONFLICT DO NOTHING
 `
 
 	args := pgx.StrictNamedArgs{
@@ -741,6 +903,7 @@ SELECT * FROM trust_center_file_access_data
 		"trust_center_document_access_entity_type": TrustCenterDocumentAccessEntityType,
 		"trust_center_access_id":                   trustCenterAccessID,
 		"trust_center_file_ids":                    trustCenterFileIDs,
+		"requested":                                requested,
 		"created_at":                               createdAt,
 		"updated_at":                               createdAt,
 	}

pkg/probo/trust_center_access_service.go

@@ -80,7 +80,7 @@ func (s TrustCenterAccessService) ListForTrustCenterID(
 	return page.NewPage(accesses, cursor), nil
 }
 
-func (s TrustCenterAccessService) ListDocumentAccesses(
+func (s TrustCenterAccessService) ListAvailableDocumentAccesses(
 	ctx context.Context,
 	trustCenterAccessID gid.GID,
 	cursor *page.Cursor[coredata.TrustCenterDocumentAccessOrderField],
@@ -90,7 +90,7 @@ func (s TrustCenterAccessService) ListDocumentAccesses(
 	err := s.svc.pg.WithConn(
 		ctx,
 		func(conn pg.Conn) error {
-			return documentAccesses.LoadByTrustCenterAccessID(ctx, conn, s.svc.scope, trustCenterAccessID, cursor)
+			return documentAccesses.LoadAvailableByTrustCenterAccessID(ctx, conn, s.svc.scope, trustCenterAccessID, cursor)
 		},
 	)
 
@@ -163,6 +163,50 @@ func (s TrustCenterAccessService) CountDocumentAccesses(
 	return count, nil
 }
 
+func (s TrustCenterAccessService) CountPendingRequestDocumentAccesses(
+	ctx context.Context,
+	trustCenterAccessID gid.GID,
+) (int, error) {
+	var count int
+	err := s.svc.pg.WithConn(
+		ctx,
+		func(conn pg.Conn) error {
+			var documentAccesses coredata.TrustCenterDocumentAccesses
+			var err error
+			count, err = documentAccesses.CountPendingRequestByTrustCenterAccessID(ctx, conn, s.svc.scope, trustCenterAccessID)
+			return err
+		},
+	)
+
+	if err != nil {
+		return 0, err
+	}
+
+	return count, nil
+}
+
+func (s TrustCenterAccessService) CountActiveDocumentAccesses(
+	ctx context.Context,
+	trustCenterAccessID gid.GID,
+) (int, error) {
+	var count int
+	err := s.svc.pg.WithConn(
+		ctx,
+		func(conn pg.Conn) error {
+			var documentAccesses coredata.TrustCenterDocumentAccesses
+			var err error
+			count, err = documentAccesses.CountActiveByTrustCenterAccessID(ctx, conn, s.svc.scope, trustCenterAccessID)
+			return err
+		},
+	)
+
+	if err != nil {
+		return 0, err
+	}
+
+	return count, nil
+}
+
 func (s TrustCenterAccessService) ValidateToken(
 	ctx context.Context,
 	tokenString string,
@@ -210,50 +254,6 @@ func (s TrustCenterAccessService) Create(
 	err := s.svc.pg.WithTx(
 		ctx,
 		func(tx pg.Conn) error {
-			trustCenter := &coredata.TrustCenter{}
-			if err := trustCenter.LoadByID(ctx, tx, s.svc.scope, req.TrustCenterID); err != nil {
-				return fmt.Errorf("cannot load trust center: %w", err)
-			}
-			organizationID := trustCenter.OrganizationID
-
-			documentIDs := []gid.GID{}
-			reportIDs := []gid.GID{}
-			trustCenterFileIDs := []gid.GID{}
-
-			var allDocuments coredata.Documents
-			filter := coredata.NewDocumentTrustCenterFilter()
-
-			if err := allDocuments.LoadAllByOrganizationID(ctx, tx, s.svc.scope, organizationID, filter); err != nil {
-				return fmt.Errorf("cannot list documents: %w", err)
-			}
-
-			for _, doc := range allDocuments {
-				documentIDs = append(documentIDs, doc.ID)
-			}
-
-			var allAudits coredata.Audits
-			auditFilter := coredata.NewAuditTrustCenterFilter()
-
-			if err := allAudits.LoadAllByOrganizationID(ctx, tx, s.svc.scope, organizationID, auditFilter); err != nil {
-				return fmt.Errorf("cannot list audits: %w", err)
-			}
-
-			for _, audit := range allAudits {
-				if audit.ReportID != nil {
-					reportIDs = append(reportIDs, *audit.ReportID)
-				}
-			}
-
-			var allTrustCenterFiles coredata.TrustCenterFiles
-
-			if err := allTrustCenterFiles.LoadAllByOrganizationID(ctx, tx, s.svc.scope, organizationID); err != nil {
-				return fmt.Errorf("cannot list trust center files: %w", err)
-			}
-
-			for _, file := range allTrustCenterFiles {
-				trustCenterFileIDs = append(trustCenterFileIDs, file.ID)
-			}
-
 			access = &coredata.TrustCenterAccess{
 				ID:                                gid.New(s.svc.scope.GetTenantID(), coredata.TrustCenterAccessEntityType),
 				TenantID:                          s.svc.scope.GetTenantID(),
@@ -270,19 +270,6 @@ func (s TrustCenterAccessService) Create(
 				return fmt.Errorf("cannot insert trust center access: %w", err)
 			}
 
-			var documentAccesses coredata.TrustCenterDocumentAccesses
-			if err := documentAccesses.BulkInsertDocumentAccesses(ctx, tx, s.svc.scope, access.ID, documentIDs, now); err != nil {
-				return fmt.Errorf("cannot bulk insert trust center document accesses: %w", err)
-			}
-
-			if err := documentAccesses.BulkInsertReportAccesses(ctx, tx, s.svc.scope, access.ID, reportIDs, now); err != nil {
-				return fmt.Errorf("cannot bulk insert trust center report accesses: %w", err)
-			}
-
-			if err := documentAccesses.BulkInsertTrustCenterFileAccesses(ctx, tx, s.svc.scope, access.ID, trustCenterFileIDs, now); err != nil {
-				return fmt.Errorf("cannot bulk insert trust center file accesses: %w", err)
-			}
-
 			return nil
 		},
 	)
@@ -328,28 +315,8 @@ func (s TrustCenterAccessService) Update(
 				return fmt.Errorf("cannot update trust center access: %w", err)
 			}
 
-			if req.DocumentIDs != nil || req.ReportIDs != nil || req.TrustCenterFileIDs != nil {
-				if err := coredata.DeactivateByTrustCenterAccessID(ctx, tx, s.svc.scope, access.ID, now); err != nil {
-					return fmt.Errorf("cannot deactivate existing document accesses: %w", err)
-				}
-
-				if req.DocumentIDs != nil {
-					if err := coredata.ActivateByDocumentIDs(ctx, tx, s.svc.scope, access.ID, req.DocumentIDs, now); err != nil {
-						return fmt.Errorf("cannot activate document accesses: %w", err)
-					}
-				}
-
-				if req.ReportIDs != nil {
-					if err := coredata.ActivateByReportIDs(ctx, tx, s.svc.scope, access.ID, req.ReportIDs, now); err != nil {
-						return fmt.Errorf("cannot activate report accesses: %w", err)
-					}
-				}
-
-				if req.TrustCenterFileIDs != nil {
-					if err := coredata.ActivateByTrustCenterFileIDs(ctx, tx, s.svc.scope, access.ID, req.TrustCenterFileIDs, now); err != nil {
-						return fmt.Errorf("cannot activate trust center file accesses: %w", err)
-					}
-				}
+			if err := s.upsertDocumentAccesses(ctx, tx, access.ID, req.DocumentIDs, req.ReportIDs, req.TrustCenterFileIDs, now); err != nil {
+				return fmt.Errorf("cannot upsert document accesses: %w", err)
 			}
 
 			if shouldSendEmail {
@@ -393,6 +360,56 @@ func (s TrustCenterAccessService) Delete(
 	return err
 }
 
+func (s TrustCenterAccessService) upsertDocumentAccesses(
+	ctx context.Context,
+	tx pg.Conn,
+	accessID gid.GID,
+	documentIDs []gid.GID,
+	reportIDs []gid.GID,
+	trustCenterFileIDs []gid.GID,
+	now time.Time,
+) error {
+	if documentIDs == nil && reportIDs == nil && trustCenterFileIDs == nil {
+		return nil
+	}
+
+	if err := coredata.DeactivateByTrustCenterAccessID(ctx, tx, s.svc.scope, accessID, now); err != nil {
+		return fmt.Errorf("cannot deactivate existing document accesses: %w", err)
+	}
+
+	if documentIDs != nil {
+		var documentAccesses coredata.TrustCenterDocumentAccesses
+		if err := documentAccesses.BulkInsertDocumentAccesses(ctx, tx, s.svc.scope, accessID, documentIDs, false, now); err != nil {
+			return fmt.Errorf("cannot create document accesses: %w", err)
+		}
+		if err := coredata.ActivateByDocumentIDs(ctx, tx, s.svc.scope, accessID, documentIDs, now); err != nil {
+			return fmt.Errorf("cannot activate document accesses: %w", err)
+		}
+	}
+
+	if reportIDs != nil {
+		var documentAccesses coredata.TrustCenterDocumentAccesses
+		if err := documentAccesses.BulkInsertReportAccesses(ctx, tx, s.svc.scope, accessID, reportIDs, false, now); err != nil {
+			return fmt.Errorf("cannot create report accesses: %w", err)
+		}
+		if err := coredata.ActivateByReportIDs(ctx, tx, s.svc.scope, accessID, reportIDs, now); err != nil {
+			return fmt.Errorf("cannot activate report accesses: %w", err)
+		}
+	}
+
+	if trustCenterFileIDs != nil {
+		var documentAccesses coredata.TrustCenterDocumentAccesses
+		if err := documentAccesses.BulkInsertTrustCenterFileAccesses(ctx, tx, s.svc.scope, accessID, trustCenterFileIDs, false, now); err != nil {
+			return fmt.Errorf("cannot create trust center file accesses: %w", err)
+		}
+		if err := coredata.ActivateByTrustCenterFileIDs(ctx, tx, s.svc.scope, accessID, trustCenterFileIDs, now); err != nil {
+			return fmt.Errorf("cannot activate trust center file accesses: %w", err)
+		}
+	}
+
+	return nil
+}
+
 func (s TrustCenterAccessService) sendAccessEmail(ctx context.Context, tx pg.Conn, access *coredata.TrustCenterAccess) error {
 	accessToken, err := statelesstoken.NewToken(
 		s.svc.trustConfig.TokenSecret,
@@ -445,6 +462,15 @@ func (s TrustCenterAccessService) sendAccessEmail(ctx context.Context, tx pg.Con
 		}.Encode(),
 	}
 
+	now := time.Now()
+	expiresAt := now.Add(s.svc.trustConfig.TokenDuration)
+	access.LastTokenExpiresAt = &expiresAt
+	access.UpdatedAt = now
+
+	if err := access.Update(ctx, tx, s.svc.scope); err != nil {
+		return fmt.Errorf("cannot update trust center access with expiration: %w", err)
+	}
+
 	return s.sendTrustCenterAccessEmail(ctx, tx, access.Name, access.Email, organization.Name, accessURL.String())
 }
 
@@ -461,6 +487,7 @@ func (s TrustCenterAccessService) sendTrustCenterAccessEmail(
 		name,
 		companyName,
 		accessURL,
+		s.svc.trustConfig.TokenDuration,
 	)
 	if err != nil {
 		return fmt.Errorf("cannot render trust center access email: %w", err)

pkg/probo/trust_center_file_service.go

@@ -54,10 +54,6 @@ type (
 		TrustCenterVisibility *coredata.TrustCenterVisibility
 	}
 
-	GetTrustCenterFileRequest struct {
-		ID gid.GID
-	}
-
 	DeleteTrustCenterFileRequest struct {
 		ID gid.GID
 	}
@@ -114,21 +110,18 @@ func (s TrustCenterFileService) CountForOrganizationID(
 
 func (s TrustCenterFileService) Get(
 	ctx context.Context,
-	req *GetTrustCenterFileRequest,
+	id gid.GID,
 ) (*coredata.TrustCenterFile, error) {
 	var file *coredata.TrustCenterFile
 
-	err := s.svc.pg.WithConn(
-		ctx,
-		func(conn pg.Conn) error {
-			file = &coredata.TrustCenterFile{}
-			if err := file.LoadByID(ctx, conn, s.svc.scope, req.ID); err != nil {
-				return fmt.Errorf("cannot load trust center file: %w", err)
-			}
+	err := s.svc.pg.WithConn(ctx, func(conn pg.Conn) error {
+		file = &coredata.TrustCenterFile{}
+		if err := file.LoadByID(ctx, conn, s.svc.scope, id); err != nil {
+			return fmt.Errorf("cannot load trust center file: %w", err)
+		}
 
-			return nil
-		},
-	)
+		return nil
+	})
 
 	if err != nil {
 		return nil, err

pkg/probod/probod.go

@@ -123,7 +123,7 @@ func New() *Implm {
 				CookieName:        "TCT",
 				CookieDomain:      "localhost",
 				CookieDuration:    24,
-				TokenDuration:     168,
+				TokenDuration:     720,
 				ReportURLDuration: 15,
 				TokenSecret:       "this-is-a-secure-secret-for-trust-token-signing-at-least-32-bytes",
 				Scope:             "trust_center_readonly",

pkg/server/api/console/v1/schema.graphql

@@ -2407,8 +2407,11 @@ type TrustCenterAccess implements Node {
   hasAcceptedNonDisclosureAgreement: Boolean!
   createdAt: Datetime!
   updatedAt: Datetime!
+  lastTokenExpiresAt: Datetime
+  pendingRequestCount: Int! @goField(forceResolver: true)
+  activeCount: Int! @goField(forceResolver: true)
 
-  documentAccesses(
+  availableDocumentAccesses(
     first: Int
     after: CursorKey
     last: Int
@@ -2417,12 +2420,12 @@ type TrustCenterAccess implements Node {
   ): TrustCenterDocumentAccessConnection! @goField(forceResolver: true)
 }
 
-type TrustCenterDocumentAccess implements Node {
-  id: ID!
+type TrustCenterDocumentAccess
+  @goModel(
+    model: "github.com/getprobo/probo/pkg/server/api/console/v1/types.TrustCenterDocumentAccess"
+  ) {
   active: Boolean!
-  createdAt: Datetime!
-  updatedAt: Datetime!
-  trustCenterAccess: TrustCenterAccess! @goField(forceResolver: true)
+  requested: Boolean!
   document: Document @goField(forceResolver: true)
   report: Report @goField(forceResolver: true)
   trustCenterFile: TrustCenterFile @goField(forceResolver: true)

pkg/server/api/console/v1/schema/schema.go

@@ -1287,12 +1287,15 @@ type ComplexityRoot struct {
 
 	TrustCenterAccess struct {
 		Active                            func(childComplexity int) int
+		ActiveCount                       func(childComplexity int) int
+		AvailableDocumentAccesses         func(childComplexity int, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.OrderBy[coredata.TrustCenterDocumentAccessOrderField]) int
 		CreatedAt                         func(childComplexity int) int
-		DocumentAccesses                  func(childComplexity int, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.OrderBy[coredata.TrustCenterDocumentAccessOrderField]) int
 		Email                             func(childComplexity int) int
 		HasAcceptedNonDisclosureAgreement func(childComplexity int) int
 		ID                                func(childComplexity int) int
+		LastTokenExpiresAt                func(childComplexity int) int
 		Name                              func(childComplexity int) int
+		PendingRequestCount               func(childComplexity int) int
 		UpdatedAt                         func(childComplexity int) int
 	}
 
@@ -1312,14 +1315,11 @@ type ComplexityRoot struct {
 	}
 
 	TrustCenterDocumentAccess struct {
-		Active            func(childComplexity int) int
-		CreatedAt         func(childComplexity int) int
-		Document          func(childComplexity int) int
-		ID                func(childComplexity int) int
-		Report            func(childComplexity int) int
-		TrustCenterAccess func(childComplexity int) int
-		TrustCenterFile   func(childComplexity int) int
-		UpdatedAt         func(childComplexity int) int
+		Active          func(childComplexity int) int
+		Document        func(childComplexity int) int
+		Report          func(childComplexity int) int
+		Requested       func(childComplexity int) int
+		TrustCenterFile func(childComplexity int) int
 	}
 
 	TrustCenterDocumentAccessConnection struct {
@@ -2017,10 +2017,11 @@ type TrustCenterResolver interface {
 	References(ctx context.Context, obj *types.TrustCenter, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.OrderBy[coredata.TrustCenterReferenceOrderField]) (*types.TrustCenterReferenceConnection, error)
 }
 type TrustCenterAccessResolver interface {
-	DocumentAccesses(ctx context.Context, obj *types.TrustCenterAccess, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.OrderBy[coredata.TrustCenterDocumentAccessOrderField]) (*types.TrustCenterDocumentAccessConnection, error)
+	PendingRequestCount(ctx context.Context, obj *types.TrustCenterAccess) (int, error)
+	ActiveCount(ctx context.Context, obj *types.TrustCenterAccess) (int, error)
+	AvailableDocumentAccesses(ctx context.Context, obj *types.TrustCenterAccess, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.OrderBy[coredata.TrustCenterDocumentAccessOrderField]) (*types.TrustCenterDocumentAccessConnection, error)
 }
 type TrustCenterDocumentAccessResolver interface {
-	TrustCenterAccess(ctx context.Context, obj *types.TrustCenterDocumentAccess) (*types.TrustCenterAccess, error)
 	Document(ctx context.Context, obj *types.TrustCenterDocumentAccess) (*types.Document, error)
 	Report(ctx context.Context, obj *types.TrustCenterDocumentAccess) (*types.Report, error)
 	TrustCenterFile(ctx context.Context, obj *types.TrustCenterDocumentAccess) (*types.TrustCenterFile, error)
@@ -7609,6 +7610,25 @@ func (e *executableSchema) Complexity(ctx context.Context, typeName, field strin
 
 		return e.complexity.TrustCenterAccess.Active(childComplexity), true
 
+	case "TrustCenterAccess.activeCount":
+		if e.complexity.TrustCenterAccess.ActiveCount == nil {
+			break
+		}
+
+		return e.complexity.TrustCenterAccess.ActiveCount(childComplexity), true
+
+	case "TrustCenterAccess.availableDocumentAccesses":
+		if e.complexity.TrustCenterAccess.AvailableDocumentAccesses == nil {
+			break
+		}
+
+		args, err := ec.field_TrustCenterAccess_availableDocumentAccesses_args(ctx, rawArgs)
+		if err != nil {
+			return 0, false
+		}
+
+		return e.complexity.TrustCenterAccess.AvailableDocumentAccesses(childComplexity, args["first"].(*int), args["after"].(*page.CursorKey), args["last"].(*int), args["before"].(*page.CursorKey), args["orderBy"].(*types.OrderBy[coredata.TrustCenterDocumentAccessOrderField])), true
+
 	case "TrustCenterAccess.createdAt":
 		if e.complexity.TrustCenterAccess.CreatedAt == nil {
 			break
@@ -7616,18 +7636,6 @@ func (e *executableSchema) Complexity(ctx context.Context, typeName, field strin
 
 		return e.complexity.TrustCenterAccess.CreatedAt(childComplexity), true
 
-	case "TrustCenterAccess.documentAccesses":
-		if e.complexity.TrustCenterAccess.DocumentAccesses == nil {
-			break
-		}
-
-		args, err := ec.field_TrustCenterAccess_documentAccesses_args(ctx, rawArgs)
-		if err != nil {
-			return 0, false
-		}
-
-		return e.complexity.TrustCenterAccess.DocumentAccesses(childComplexity, args["first"].(*int), args["after"].(*page.CursorKey), args["last"].(*int), args["before"].(*page.CursorKey), args["orderBy"].(*types.OrderBy[coredata.TrustCenterDocumentAccessOrderField])), true
-
 	case "TrustCenterAccess.email":
 		if e.complexity.TrustCenterAccess.Email == nil {
 			break
@@ -7649,6 +7657,13 @@ func (e *executableSchema) Complexity(ctx context.Context, typeName, field strin
 
 		return e.complexity.TrustCenterAccess.ID(childComplexity), true
 
+	case "TrustCenterAccess.lastTokenExpiresAt":
+		if e.complexity.TrustCenterAccess.LastTokenExpiresAt == nil {
+			break
+		}
+
+		return e.complexity.TrustCenterAccess.LastTokenExpiresAt(childComplexity), true
+
 	case "TrustCenterAccess.name":
 		if e.complexity.TrustCenterAccess.Name == nil {
 			break
@@ -7656,6 +7671,13 @@ func (e *executableSchema) Complexity(ctx context.Context, typeName, field strin
 
 		return e.complexity.TrustCenterAccess.Name(childComplexity), true
 
+	case "TrustCenterAccess.pendingRequestCount":
+		if e.complexity.TrustCenterAccess.PendingRequestCount == nil {
+			break
+		}
+
+		return e.complexity.TrustCenterAccess.PendingRequestCount(childComplexity), true
+
 	case "TrustCenterAccess.updatedAt":
 		if e.complexity.TrustCenterAccess.UpdatedAt == nil {
 			break
@@ -7712,13 +7734,6 @@ func (e *executableSchema) Complexity(ctx context.Context, typeName, field strin
 
 		return e.complexity.TrustCenterDocumentAccess.Active(childComplexity), true
 
-	case "TrustCenterDocumentAccess.createdAt":
-		if e.complexity.TrustCenterDocumentAccess.CreatedAt == nil {
-			break
-		}
-
-		return e.complexity.TrustCenterDocumentAccess.CreatedAt(childComplexity), true
-
 	case "TrustCenterDocumentAccess.document":
 		if e.complexity.TrustCenterDocumentAccess.Document == nil {
 			break
@@ -7726,13 +7741,6 @@ func (e *executableSchema) Complexity(ctx context.Context, typeName, field strin
 
 		return e.complexity.TrustCenterDocumentAccess.Document(childComplexity), true
 
-	case "TrustCenterDocumentAccess.id":
-		if e.complexity.TrustCenterDocumentAccess.ID == nil {
-			break
-		}
-
-		return e.complexity.TrustCenterDocumentAccess.ID(childComplexity), true
-
 	case "TrustCenterDocumentAccess.report":
 		if e.complexity.TrustCenterDocumentAccess.Report == nil {
 			break
@@ -7740,12 +7748,12 @@ func (e *executableSchema) Complexity(ctx context.Context, typeName, field strin
 
 		return e.complexity.TrustCenterDocumentAccess.Report(childComplexity), true
 
-	case "TrustCenterDocumentAccess.trustCenterAccess":
-		if e.complexity.TrustCenterDocumentAccess.TrustCenterAccess == nil {
+	case "TrustCenterDocumentAccess.requested":
+		if e.complexity.TrustCenterDocumentAccess.Requested == nil {
 			break
 		}
 
-		return e.complexity.TrustCenterDocumentAccess.TrustCenterAccess(childComplexity), true
+		return e.complexity.TrustCenterDocumentAccess.Requested(childComplexity), true
 
 	case "TrustCenterDocumentAccess.trustCenterFile":
 		if e.complexity.TrustCenterDocumentAccess.TrustCenterFile == nil {
@@ -7754,13 +7762,6 @@ func (e *executableSchema) Complexity(ctx context.Context, typeName, field strin
 
 		return e.complexity.TrustCenterDocumentAccess.TrustCenterFile(childComplexity), true
 
-	case "TrustCenterDocumentAccess.updatedAt":
-		if e.complexity.TrustCenterDocumentAccess.UpdatedAt == nil {
-			break
-		}
-
-		return e.complexity.TrustCenterDocumentAccess.UpdatedAt(childComplexity), true
-
 	case "TrustCenterDocumentAccessConnection.edges":
 		if e.complexity.TrustCenterDocumentAccessConnection.Edges == nil {
 			break
@@ -11724,8 +11725,11 @@ type TrustCenterAccess implements Node {
   hasAcceptedNonDisclosureAgreement: Boolean!
   createdAt: Datetime!
   updatedAt: Datetime!
+  lastTokenExpiresAt: Datetime
+  pendingRequestCount: Int! @goField(forceResolver: true)
+  activeCount: Int! @goField(forceResolver: true)
 
-  documentAccesses(
+  availableDocumentAccesses(
     first: Int
     after: CursorKey
     last: Int
@@ -11734,12 +11738,12 @@ type TrustCenterAccess implements Node {
   ): TrustCenterDocumentAccessConnection! @goField(forceResolver: true)
 }
 
-type TrustCenterDocumentAccess implements Node {
-  id: ID!
+type TrustCenterDocumentAccess
+  @goModel(
+    model: "github.com/getprobo/probo/pkg/server/api/console/v1/types.TrustCenterDocumentAccess"
+  ) {
   active: Boolean!
-  createdAt: Datetime!
-  updatedAt: Datetime!
-  trustCenterAccess: TrustCenterAccess! @goField(forceResolver: true)
+  requested: Boolean!
   document: Document @goField(forceResolver: true)
   report: Report @goField(forceResolver: true)
   trustCenterFile: TrustCenterFile @goField(forceResolver: true)
@@ -21371,37 +21375,37 @@ func (ec *executionContext) field_Task_evidences_argsOrderBy(
 	return zeroVal, nil
 }
 
-func (ec *executionContext) field_TrustCenterAccess_documentAccesses_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
+func (ec *executionContext) field_TrustCenterAccess_availableDocumentAccesses_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
 	var err error
 	args := map[string]any{}
-	arg0, err := ec.field_TrustCenterAccess_documentAccesses_argsFirst(ctx, rawArgs)
+	arg0, err := ec.field_TrustCenterAccess_availableDocumentAccesses_argsFirst(ctx, rawArgs)
 	if err != nil {
 		return nil, err
 	}
 	args["first"] = arg0
-	arg1, err := ec.field_TrustCenterAccess_documentAccesses_argsAfter(ctx, rawArgs)
+	arg1, err := ec.field_TrustCenterAccess_availableDocumentAccesses_argsAfter(ctx, rawArgs)
 	if err != nil {
 		return nil, err
 	}
 	args["after"] = arg1
-	arg2, err := ec.field_TrustCenterAccess_documentAccesses_argsLast(ctx, rawArgs)
+	arg2, err := ec.field_TrustCenterAccess_availableDocumentAccesses_argsLast(ctx, rawArgs)
 	if err != nil {
 		return nil, err
 	}
 	args["last"] = arg2
-	arg3, err := ec.field_TrustCenterAccess_documentAccesses_argsBefore(ctx, rawArgs)
+	arg3, err := ec.field_TrustCenterAccess_availableDocumentAccesses_argsBefore(ctx, rawArgs)
 	if err != nil {
 		return nil, err
 	}
 	args["before"] = arg3
-	arg4, err := ec.field_TrustCenterAccess_documentAccesses_argsOrderBy(ctx, rawArgs)
+	arg4, err := ec.field_TrustCenterAccess_availableDocumentAccesses_argsOrderBy(ctx, rawArgs)
 	if err != nil {
 		return nil, err
 	}
 	args["orderBy"] = arg4
 	return args, nil
 }
-func (ec *executionContext) field_TrustCenterAccess_documentAccesses_argsFirst(
+func (ec *executionContext) field_TrustCenterAccess_availableDocumentAccesses_argsFirst(
 	ctx context.Context,
 	rawArgs map[string]any,
 ) (*int, error) {
@@ -21414,7 +21418,7 @@ func (ec *executionContext) field_TrustCenterAccess_documentAccesses_argsFirst(
 	return zeroVal, nil
 }
 
-func (ec *executionContext) field_TrustCenterAccess_documentAccesses_argsAfter(
+func (ec *executionContext) field_TrustCenterAccess_availableDocumentAccesses_argsAfter(
 	ctx context.Context,
 	rawArgs map[string]any,
 ) (*page.CursorKey, error) {
@@ -21427,7 +21431,7 @@ func (ec *executionContext) field_TrustCenterAccess_documentAccesses_argsAfter(
 	return zeroVal, nil
 }
 
-func (ec *executionContext) field_TrustCenterAccess_documentAccesses_argsLast(
+func (ec *executionContext) field_TrustCenterAccess_availableDocumentAccesses_argsLast(
 	ctx context.Context,
 	rawArgs map[string]any,
 ) (*int, error) {
@@ -21440,7 +21444,7 @@ func (ec *executionContext) field_TrustCenterAccess_documentAccesses_argsLast(
 	return zeroVal, nil
 }
 
-func (ec *executionContext) field_TrustCenterAccess_documentAccesses_argsBefore(
+func (ec *executionContext) field_TrustCenterAccess_availableDocumentAccesses_argsBefore(
 	ctx context.Context,
 	rawArgs map[string]any,
 ) (*page.CursorKey, error) {
@@ -21453,7 +21457,7 @@ func (ec *executionContext) field_TrustCenterAccess_documentAccesses_argsBefore(
 	return zeroVal, nil
 }
 
-func (ec *executionContext) field_TrustCenterAccess_documentAccesses_argsOrderBy(
+func (ec *executionContext) field_TrustCenterAccess_availableDocumentAccesses_argsOrderBy(
 	ctx context.Context,
 	rawArgs map[string]any,
 ) (*types.OrderBy[coredata.TrustCenterDocumentAccessOrderField], error) {
@@ -57622,8 +57626,8 @@ func (ec *executionContext) fieldContext_TrustCenterAccess_updatedAt(_ context.C
 	return fc, nil
 }
 
-func (ec *executionContext) _TrustCenterAccess_documentAccesses(ctx context.Context, field graphql.CollectedField, obj *types.TrustCenterAccess) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_TrustCenterAccess_documentAccesses(ctx, field)
+func (ec *executionContext) _TrustCenterAccess_lastTokenExpiresAt(ctx context.Context, field graphql.CollectedField, obj *types.TrustCenterAccess) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_TrustCenterAccess_lastTokenExpiresAt(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -57636,7 +57640,136 @@ func (ec *executionContext) _TrustCenterAccess_documentAccesses(ctx context.Cont
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.TrustCenterAccess().DocumentAccesses(rctx, obj, fc.Args["first"].(*int), fc.Args["after"].(*page.CursorKey), fc.Args["last"].(*int), fc.Args["before"].(*page.CursorKey), fc.Args["orderBy"].(*types.OrderBy[coredata.TrustCenterDocumentAccessOrderField]))
+		return obj.LastTokenExpiresAt, nil
+	})
+	if err != nil {
+		ec.Error(ctx, err)
+		return graphql.Null
+	}
+	if resTmp == nil {
+		return graphql.Null
+	}
+	res := resTmp.(*time.Time)
+	fc.Result = res
+	return ec.marshalODatetime2ᚖtimeᚐTime(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_TrustCenterAccess_lastTokenExpiresAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+	fc = &graphql.FieldContext{
+		Object:     "TrustCenterAccess",
+		Field:      field,
+		IsMethod:   false,
+		IsResolver: false,
+		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+			return nil, errors.New("field of type Datetime does not have child fields")
+		},
+	}
+	return fc, nil
+}
+
+func (ec *executionContext) _TrustCenterAccess_pendingRequestCount(ctx context.Context, field graphql.CollectedField, obj *types.TrustCenterAccess) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_TrustCenterAccess_pendingRequestCount(ctx, field)
+	if err != nil {
+		return graphql.Null
+	}
+	ctx = graphql.WithFieldContext(ctx, fc)
+	defer func() {
+		if r := recover(); r != nil {
+			ec.Error(ctx, ec.Recover(ctx, r))
+			ret = graphql.Null
+		}
+	}()
+	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
+		ctx = rctx // use context from middleware stack in children
+		return ec.resolvers.TrustCenterAccess().PendingRequestCount(rctx, obj)
+	})
+	if err != nil {
+		ec.Error(ctx, err)
+		return graphql.Null
+	}
+	if resTmp == nil {
+		if !graphql.HasFieldError(ctx, fc) {
+			ec.Errorf(ctx, "must not be null")
+		}
+		return graphql.Null
+	}
+	res := resTmp.(int)
+	fc.Result = res
+	return ec.marshalNInt2int(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_TrustCenterAccess_pendingRequestCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+	fc = &graphql.FieldContext{
+		Object:     "TrustCenterAccess",
+		Field:      field,
+		IsMethod:   true,
+		IsResolver: true,
+		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+			return nil, errors.New("field of type Int does not have child fields")
+		},
+	}
+	return fc, nil
+}
+
+func (ec *executionContext) _TrustCenterAccess_activeCount(ctx context.Context, field graphql.CollectedField, obj *types.TrustCenterAccess) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_TrustCenterAccess_activeCount(ctx, field)
+	if err != nil {
+		return graphql.Null
+	}
+	ctx = graphql.WithFieldContext(ctx, fc)
+	defer func() {
+		if r := recover(); r != nil {
+			ec.Error(ctx, ec.Recover(ctx, r))
+			ret = graphql.Null
+		}
+	}()
+	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
+		ctx = rctx // use context from middleware stack in children
+		return ec.resolvers.TrustCenterAccess().ActiveCount(rctx, obj)
+	})
+	if err != nil {
+		ec.Error(ctx, err)
+		return graphql.Null
+	}
+	if resTmp == nil {
+		if !graphql.HasFieldError(ctx, fc) {
+			ec.Errorf(ctx, "must not be null")
+		}
+		return graphql.Null
+	}
+	res := resTmp.(int)
+	fc.Result = res
+	return ec.marshalNInt2int(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_TrustCenterAccess_activeCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+	fc = &graphql.FieldContext{
+		Object:     "TrustCenterAccess",
+		Field:      field,
+		IsMethod:   true,
+		IsResolver: true,
+		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+			return nil, errors.New("field of type Int does not have child fields")
+		},
+	}
+	return fc, nil
+}
+
+func (ec *executionContext) _TrustCenterAccess_availableDocumentAccesses(ctx context.Context, field graphql.CollectedField, obj *types.TrustCenterAccess) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_TrustCenterAccess_availableDocumentAccesses(ctx, field)
+	if err != nil {
+		return graphql.Null
+	}
+	ctx = graphql.WithFieldContext(ctx, fc)
+	defer func() {
+		if r := recover(); r != nil {
+			ec.Error(ctx, ec.Recover(ctx, r))
+			ret = graphql.Null
+		}
+	}()
+	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
+		ctx = rctx // use context from middleware stack in children
+		return ec.resolvers.TrustCenterAccess().AvailableDocumentAccesses(rctx, obj, fc.Args["first"].(*int), fc.Args["after"].(*page.CursorKey), fc.Args["last"].(*int), fc.Args["before"].(*page.CursorKey), fc.Args["orderBy"].(*types.OrderBy[coredata.TrustCenterDocumentAccessOrderField]))
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -57653,7 +57786,7 @@ func (ec *executionContext) _TrustCenterAccess_documentAccesses(ctx context.Cont
 	return ec.marshalNTrustCenterDocumentAccessConnection2ᚖgithubᚗcomᚋgetproboᚋproboᚋpkgᚋserverᚋapiᚋconsoleᚋv1ᚋtypesᚐTrustCenterDocumentAccessConnection(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_TrustCenterAccess_documentAccesses(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_TrustCenterAccess_availableDocumentAccesses(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
 		Object:     "TrustCenterAccess",
 		Field:      field,
@@ -57678,7 +57811,7 @@ func (ec *executionContext) fieldContext_TrustCenterAccess_documentAccesses(ctx
 		}
 	}()
 	ctx = graphql.WithFieldContext(ctx, fc)
-	if fc.Args, err = ec.field_TrustCenterAccess_documentAccesses_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
+	if fc.Args, err = ec.field_TrustCenterAccess_availableDocumentAccesses_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
 		ec.Error(ctx, err)
 		return fc, err
 	}
@@ -57886,8 +58019,14 @@ func (ec *executionContext) fieldContext_TrustCenterAccessEdge_node(_ context.Co
 				return ec.fieldContext_TrustCenterAccess_createdAt(ctx, field)
 			case "updatedAt":
 				return ec.fieldContext_TrustCenterAccess_updatedAt(ctx, field)
-			case "documentAccesses":
-				return ec.fieldContext_TrustCenterAccess_documentAccesses(ctx, field)
+			case "lastTokenExpiresAt":
+				return ec.fieldContext_TrustCenterAccess_lastTokenExpiresAt(ctx, field)
+			case "pendingRequestCount":
+				return ec.fieldContext_TrustCenterAccess_pendingRequestCount(ctx, field)
+			case "activeCount":
+				return ec.fieldContext_TrustCenterAccess_activeCount(ctx, field)
+			case "availableDocumentAccesses":
+				return ec.fieldContext_TrustCenterAccess_availableDocumentAccesses(ctx, field)
 			}
 			return nil, fmt.Errorf("no field named %q was found under type TrustCenterAccess", field.Name)
 		},
@@ -57999,50 +58138,6 @@ func (ec *executionContext) fieldContext_TrustCenterConnection_pageInfo(_ contex
 	return fc, nil
 }
 
-func (ec *executionContext) _TrustCenterDocumentAccess_id(ctx context.Context, field graphql.CollectedField, obj *types.TrustCenterDocumentAccess) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_TrustCenterDocumentAccess_id(ctx, field)
-	if err != nil {
-		return graphql.Null
-	}
-	ctx = graphql.WithFieldContext(ctx, fc)
-	defer func() {
-		if r := recover(); r != nil {
-			ec.Error(ctx, ec.Recover(ctx, r))
-			ret = graphql.Null
-		}
-	}()
-	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
-		ctx = rctx // use context from middleware stack in children
-		return obj.ID, nil
-	})
-	if err != nil {
-		ec.Error(ctx, err)
-		return graphql.Null
-	}
-	if resTmp == nil {
-		if !graphql.HasFieldError(ctx, fc) {
-			ec.Errorf(ctx, "must not be null")
-		}
-		return graphql.Null
-	}
-	res := resTmp.(gid.GID)
-	fc.Result = res
-	return ec.marshalNID2githubᚗcomᚋgetproboᚋproboᚋpkgᚋgidᚐGID(ctx, field.Selections, res)
-}
-
-func (ec *executionContext) fieldContext_TrustCenterDocumentAccess_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
-	fc = &graphql.FieldContext{
-		Object:     "TrustCenterDocumentAccess",
-		Field:      field,
-		IsMethod:   false,
-		IsResolver: false,
-		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
-			return nil, errors.New("field of type ID does not have child fields")
-		},
-	}
-	return fc, nil
-}
-
 func (ec *executionContext) _TrustCenterDocumentAccess_active(ctx context.Context, field graphql.CollectedField, obj *types.TrustCenterDocumentAccess) (ret graphql.Marshaler) {
 	fc, err := ec.fieldContext_TrustCenterDocumentAccess_active(ctx, field)
 	if err != nil {
@@ -58087,8 +58182,8 @@ func (ec *executionContext) fieldContext_TrustCenterDocumentAccess_active(_ cont
 	return fc, nil
 }
 
-func (ec *executionContext) _TrustCenterDocumentAccess_createdAt(ctx context.Context, field graphql.CollectedField, obj *types.TrustCenterDocumentAccess) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_TrustCenterDocumentAccess_createdAt(ctx, field)
+func (ec *executionContext) _TrustCenterDocumentAccess_requested(ctx context.Context, field graphql.CollectedField, obj *types.TrustCenterDocumentAccess) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_TrustCenterDocumentAccess_requested(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -58101,7 +58196,7 @@ func (ec *executionContext) _TrustCenterDocumentAccess_createdAt(ctx context.Con
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 		ctx = rctx // use context from middleware stack in children
-		return obj.CreatedAt, nil
+		return obj.Requested, nil
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -58113,125 +58208,19 @@ func (ec *executionContext) _TrustCenterDocumentAccess_createdAt(ctx context.Con
 		}
 		return graphql.Null
 	}
-	res := resTmp.(time.Time)
+	res := resTmp.(bool)
 	fc.Result = res
-	return ec.marshalNDatetime2timeᚐTime(ctx, field.Selections, res)
+	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_TrustCenterDocumentAccess_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_TrustCenterDocumentAccess_requested(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
 		Object:     "TrustCenterDocumentAccess",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
 		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
-			return nil, errors.New("field of type Datetime does not have child fields")
-		},
-	}
-	return fc, nil
-}
-
-func (ec *executionContext) _TrustCenterDocumentAccess_updatedAt(ctx context.Context, field graphql.CollectedField, obj *types.TrustCenterDocumentAccess) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_TrustCenterDocumentAccess_updatedAt(ctx, field)
-	if err != nil {
-		return graphql.Null
-	}
-	ctx = graphql.WithFieldContext(ctx, fc)
-	defer func() {
-		if r := recover(); r != nil {
-			ec.Error(ctx, ec.Recover(ctx, r))
-			ret = graphql.Null
-		}
-	}()
-	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
-		ctx = rctx // use context from middleware stack in children
-		return obj.UpdatedAt, nil
-	})
-	if err != nil {
-		ec.Error(ctx, err)
-		return graphql.Null
-	}
-	if resTmp == nil {
-		if !graphql.HasFieldError(ctx, fc) {
-			ec.Errorf(ctx, "must not be null")
-		}
-		return graphql.Null
-	}
-	res := resTmp.(time.Time)
-	fc.Result = res
-	return ec.marshalNDatetime2timeᚐTime(ctx, field.Selections, res)
-}
-
-func (ec *executionContext) fieldContext_TrustCenterDocumentAccess_updatedAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
-	fc = &graphql.FieldContext{
-		Object:     "TrustCenterDocumentAccess",
-		Field:      field,
-		IsMethod:   false,
-		IsResolver: false,
-		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
-			return nil, errors.New("field of type Datetime does not have child fields")
-		},
-	}
-	return fc, nil
-}
-
-func (ec *executionContext) _TrustCenterDocumentAccess_trustCenterAccess(ctx context.Context, field graphql.CollectedField, obj *types.TrustCenterDocumentAccess) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_TrustCenterDocumentAccess_trustCenterAccess(ctx, field)
-	if err != nil {
-		return graphql.Null
-	}
-	ctx = graphql.WithFieldContext(ctx, fc)
-	defer func() {
-		if r := recover(); r != nil {
-			ec.Error(ctx, ec.Recover(ctx, r))
-			ret = graphql.Null
-		}
-	}()
-	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
-		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.TrustCenterDocumentAccess().TrustCenterAccess(rctx, obj)
-	})
-	if err != nil {
-		ec.Error(ctx, err)
-		return graphql.Null
-	}
-	if resTmp == nil {
-		if !graphql.HasFieldError(ctx, fc) {
-			ec.Errorf(ctx, "must not be null")
-		}
-		return graphql.Null
-	}
-	res := resTmp.(*types.TrustCenterAccess)
-	fc.Result = res
-	return ec.marshalNTrustCenterAccess2ᚖgithubᚗcomᚋgetproboᚋproboᚋpkgᚋserverᚋapiᚋconsoleᚋv1ᚋtypesᚐTrustCenterAccess(ctx, field.Selections, res)
-}
-
-func (ec *executionContext) fieldContext_TrustCenterDocumentAccess_trustCenterAccess(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
-	fc = &graphql.FieldContext{
-		Object:     "TrustCenterDocumentAccess",
-		Field:      field,
-		IsMethod:   true,
-		IsResolver: true,
-		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
-			switch field.Name {
-			case "id":
-				return ec.fieldContext_TrustCenterAccess_id(ctx, field)
-			case "email":
-				return ec.fieldContext_TrustCenterAccess_email(ctx, field)
-			case "name":
-				return ec.fieldContext_TrustCenterAccess_name(ctx, field)
-			case "active":
-				return ec.fieldContext_TrustCenterAccess_active(ctx, field)
-			case "hasAcceptedNonDisclosureAgreement":
-				return ec.fieldContext_TrustCenterAccess_hasAcceptedNonDisclosureAgreement(ctx, field)
-			case "createdAt":
-				return ec.fieldContext_TrustCenterAccess_createdAt(ctx, field)
-			case "updatedAt":
-				return ec.fieldContext_TrustCenterAccess_updatedAt(ctx, field)
-			case "documentAccesses":
-				return ec.fieldContext_TrustCenterAccess_documentAccesses(ctx, field)
-			}
-			return nil, fmt.Errorf("no field named %q was found under type TrustCenterAccess", field.Name)
+			return nil, errors.New("field of type Boolean does not have child fields")
 		},
 	}
 	return fc, nil
@@ -58657,16 +58646,10 @@ func (ec *executionContext) fieldContext_TrustCenterDocumentAccessEdge_node(_ co
 		IsResolver: false,
 		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 			switch field.Name {
-			case "id":
-				return ec.fieldContext_TrustCenterDocumentAccess_id(ctx, field)
 			case "active":
 				return ec.fieldContext_TrustCenterDocumentAccess_active(ctx, field)
-			case "createdAt":
-				return ec.fieldContext_TrustCenterDocumentAccess_createdAt(ctx, field)
-			case "updatedAt":
-				return ec.fieldContext_TrustCenterDocumentAccess_updatedAt(ctx, field)
-			case "trustCenterAccess":
-				return ec.fieldContext_TrustCenterDocumentAccess_trustCenterAccess(ctx, field)
+			case "requested":
+				return ec.fieldContext_TrustCenterDocumentAccess_requested(ctx, field)
 			case "document":
 				return ec.fieldContext_TrustCenterDocumentAccess_document(ctx, field)
 			case "report":
@@ -61337,8 +61320,14 @@ func (ec *executionContext) fieldContext_UpdateTrustCenterAccessPayload_trustCen
 				return ec.fieldContext_TrustCenterAccess_createdAt(ctx, field)
 			case "updatedAt":
 				return ec.fieldContext_TrustCenterAccess_updatedAt(ctx, field)
-			case "documentAccesses":
-				return ec.fieldContext_TrustCenterAccess_documentAccesses(ctx, field)
+			case "lastTokenExpiresAt":
+				return ec.fieldContext_TrustCenterAccess_lastTokenExpiresAt(ctx, field)
+			case "pendingRequestCount":
+				return ec.fieldContext_TrustCenterAccess_pendingRequestCount(ctx, field)
+			case "activeCount":
+				return ec.fieldContext_TrustCenterAccess_activeCount(ctx, field)
+			case "availableDocumentAccesses":
+				return ec.fieldContext_TrustCenterAccess_availableDocumentAccesses(ctx, field)
 			}
 			return nil, fmt.Errorf("no field named %q was found under type TrustCenterAccess", field.Name)
 		},
@@ -77458,13 +77447,6 @@ func (ec *executionContext) _Node(ctx context.Context, sel ast.SelectionSet, obj
 			return graphql.Null
 		}
 		return ec._TrustCenterFile(ctx, sel, obj)
-	case types.TrustCenterDocumentAccess:
-		return ec._TrustCenterDocumentAccess(ctx, sel, &obj)
-	case *types.TrustCenterDocumentAccess:
-		if obj == nil {
-			return graphql.Null
-		}
-		return ec._TrustCenterDocumentAccess(ctx, sel, obj)
 	case types.TrustCenterAccess:
 		return ec._TrustCenterAccess(ctx, sel, &obj)
 	case *types.TrustCenterAccess:
@@ -90142,7 +90124,9 @@ func (ec *executionContext) _TrustCenterAccess(ctx context.Context, sel ast.Sele
 			if out.Values[i] == graphql.Null {
 				atomic.AddUint32(&out.Invalids, 1)
 			}
-		case "documentAccesses":
+		case "lastTokenExpiresAt":
+			out.Values[i] = ec._TrustCenterAccess_lastTokenExpiresAt(ctx, field, obj)
+		case "pendingRequestCount":
 			field := field
 
 			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
@@ -90151,7 +90135,79 @@ func (ec *executionContext) _TrustCenterAccess(ctx context.Context, sel ast.Sele
 						ec.Error(ctx, ec.Recover(ctx, r))
 					}
 				}()
-				res = ec._TrustCenterAccess_documentAccesses(ctx, field, obj)
+				res = ec._TrustCenterAccess_pendingRequestCount(ctx, field, obj)
+				if res == graphql.Null {
+					atomic.AddUint32(&fs.Invalids, 1)
+				}
+				return res
+			}
+
+			if field.Deferrable != nil {
+				dfs, ok := deferred[field.Deferrable.Label]
+				di := 0
+				if ok {
+					dfs.AddField(field)
+					di = len(dfs.Values) - 1
+				} else {
+					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+					deferred[field.Deferrable.Label] = dfs
+				}
+				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+					return innerFunc(ctx, dfs)
+				})
+
+				// don't run the out.Concurrently() call below
+				out.Values[i] = graphql.Null
+				continue
+			}
+
+			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
+		case "activeCount":
+			field := field
+
+			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
+				defer func() {
+					if r := recover(); r != nil {
+						ec.Error(ctx, ec.Recover(ctx, r))
+					}
+				}()
+				res = ec._TrustCenterAccess_activeCount(ctx, field, obj)
+				if res == graphql.Null {
+					atomic.AddUint32(&fs.Invalids, 1)
+				}
+				return res
+			}
+
+			if field.Deferrable != nil {
+				dfs, ok := deferred[field.Deferrable.Label]
+				di := 0
+				if ok {
+					dfs.AddField(field)
+					di = len(dfs.Values) - 1
+				} else {
+					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+					deferred[field.Deferrable.Label] = dfs
+				}
+				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+					return innerFunc(ctx, dfs)
+				})
+
+				// don't run the out.Concurrently() call below
+				out.Values[i] = graphql.Null
+				continue
+			}
+
+			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
+		case "availableDocumentAccesses":
+			field := field
+
+			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
+				defer func() {
+					if r := recover(); r != nil {
+						ec.Error(ctx, ec.Recover(ctx, r))
+					}
+				}()
+				res = ec._TrustCenterAccess_availableDocumentAccesses(ctx, field, obj)
 				if res == graphql.Null {
 					atomic.AddUint32(&fs.Invalids, 1)
 				}
@@ -90333,7 +90389,7 @@ func (ec *executionContext) _TrustCenterConnection(ctx context.Context, sel ast.
 	return out
 }
 
-var trustCenterDocumentAccessImplementors = []string{"TrustCenterDocumentAccess", "Node"}
+var trustCenterDocumentAccessImplementors = []string{"TrustCenterDocumentAccess"}
 
 func (ec *executionContext) _TrustCenterDocumentAccess(ctx context.Context, sel ast.SelectionSet, obj *types.TrustCenterDocumentAccess) graphql.Marshaler {
 	fields := graphql.CollectFields(ec.OperationContext, sel, trustCenterDocumentAccessImplementors)
@@ -90344,62 +90400,16 @@ func (ec *executionContext) _TrustCenterDocumentAccess(ctx context.Context, sel
 		switch field.Name {
 		case "__typename":
 			out.Values[i] = graphql.MarshalString("TrustCenterDocumentAccess")
-		case "id":
-			out.Values[i] = ec._TrustCenterDocumentAccess_id(ctx, field, obj)
-			if out.Values[i] == graphql.Null {
-				atomic.AddUint32(&out.Invalids, 1)
-			}
 		case "active":
 			out.Values[i] = ec._TrustCenterDocumentAccess_active(ctx, field, obj)
 			if out.Values[i] == graphql.Null {
 				atomic.AddUint32(&out.Invalids, 1)
 			}
-		case "createdAt":
-			out.Values[i] = ec._TrustCenterDocumentAccess_createdAt(ctx, field, obj)
+		case "requested":
+			out.Values[i] = ec._TrustCenterDocumentAccess_requested(ctx, field, obj)
 			if out.Values[i] == graphql.Null {
 				atomic.AddUint32(&out.Invalids, 1)
 			}
-		case "updatedAt":
-			out.Values[i] = ec._TrustCenterDocumentAccess_updatedAt(ctx, field, obj)
-			if out.Values[i] == graphql.Null {
-				atomic.AddUint32(&out.Invalids, 1)
-			}
-		case "trustCenterAccess":
-			field := field
-
-			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
-				defer func() {
-					if r := recover(); r != nil {
-						ec.Error(ctx, ec.Recover(ctx, r))
-					}
-				}()
-				res = ec._TrustCenterDocumentAccess_trustCenterAccess(ctx, field, obj)
-				if res == graphql.Null {
-					atomic.AddUint32(&fs.Invalids, 1)
-				}
-				return res
-			}
-
-			if field.Deferrable != nil {
-				dfs, ok := deferred[field.Deferrable.Label]
-				di := 0
-				if ok {
-					dfs.AddField(field)
-					di = len(dfs.Values) - 1
-				} else {
-					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
-					deferred[field.Deferrable.Label] = dfs
-				}
-				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
-					return innerFunc(ctx, dfs)
-				})
-
-				// don't run the out.Concurrently() call below
-				out.Values[i] = graphql.Null
-				continue
-			}
-
-			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
 		case "document":
 			field := field
 
@@ -100961,10 +100971,6 @@ func (ec *executionContext) marshalNTrustCenter2ᚖgithubᚗcomᚋgetproboᚋpro
 	return ec._TrustCenter(ctx, sel, v)
 }
 
-func (ec *executionContext) marshalNTrustCenterAccess2githubᚗcomᚋgetproboᚋproboᚋpkgᚋserverᚋapiᚋconsoleᚋv1ᚋtypesᚐTrustCenterAccess(ctx context.Context, sel ast.SelectionSet, v types.TrustCenterAccess) graphql.Marshaler {
-	return ec._TrustCenterAccess(ctx, sel, &v)
-}
-
 func (ec *executionContext) marshalNTrustCenterAccess2ᚖgithubᚗcomᚋgetproboᚋproboᚋpkgᚋserverᚋapiᚋconsoleᚋv1ᚋtypesᚐTrustCenterAccess(ctx context.Context, sel ast.SelectionSet, v *types.TrustCenterAccess) graphql.Marshaler {
 	if v == nil {
 		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {

pkg/server/api/console/v1/types/trust_center_document_access.go

@@ -15,6 +15,8 @@
 package types
 
 import (
+	"time"
+
 	"github.com/getprobo/probo/pkg/coredata"
 	"github.com/getprobo/probo/pkg/gid"
 	"github.com/getprobo/probo/pkg/page"
@@ -31,14 +33,35 @@ type (
 		Resolver any
 		ParentID gid.GID
 	}
+
+	TrustCenterDocumentAccess struct {
+		ID                gid.GID            `json:"id"`
+		Active            bool               `json:"active"`
+		Requested         bool               `json:"requested"`
+		CreatedAt         time.Time          `json:"createdAt"`
+		UpdatedAt         time.Time          `json:"updatedAt"`
+		TrustCenterAccess *TrustCenterAccess `json:"trustCenterAccess"`
+		Document          *Document          `json:"document,omitempty"`
+		Report            *Report            `json:"report,omitempty"`
+		TrustCenterFile   *TrustCenterFile   `json:"trustCenterFile,omitempty"`
+
+		// Internal fields used by resolvers
+		DocumentID        *gid.GID `json:"-"`
+		ReportID          *gid.GID `json:"-"`
+		TrustCenterFileID *gid.GID `json:"-"`
+	}
 )
 
 func NewTrustCenterDocumentAccess(tcda *coredata.TrustCenterDocumentAccess) *TrustCenterDocumentAccess {
 	return &TrustCenterDocumentAccess{
-		ID:        tcda.ID,
-		Active:    tcda.Active,
-		CreatedAt: tcda.CreatedAt,
-		UpdatedAt: tcda.UpdatedAt,
+		ID:                tcda.ID,
+		Active:            tcda.Active,
+		Requested:         tcda.Requested,
+		CreatedAt:         tcda.CreatedAt,
+		UpdatedAt:         tcda.UpdatedAt,
+		DocumentID:        tcda.DocumentID,
+		ReportID:          tcda.ReportID,
+		TrustCenterFileID: tcda.TrustCenterFileID,
 	}
 }
 

pkg/server/api/console/v1/types/types.go

@@ -1675,7 +1675,10 @@ type TrustCenterAccess struct {
 	HasAcceptedNonDisclosureAgreement bool                                 `json:"hasAcceptedNonDisclosureAgreement"`
 	CreatedAt                         time.Time                            `json:"createdAt"`
 	UpdatedAt                         time.Time                            `json:"updatedAt"`
-	DocumentAccesses                  *TrustCenterDocumentAccessConnection `json:"documentAccesses"`
+	LastTokenExpiresAt                *time.Time                           `json:"lastTokenExpiresAt,omitempty"`
+	PendingRequestCount               int                                  `json:"pendingRequestCount"`
+	ActiveCount                       int                                  `json:"activeCount"`
+	AvailableDocumentAccesses         *TrustCenterDocumentAccessConnection `json:"availableDocumentAccesses"`
 }
 
 func (TrustCenterAccess) IsNode()             {}
@@ -1696,20 +1699,6 @@ type TrustCenterConnection struct {
 	PageInfo *PageInfo          `json:"pageInfo"`
 }
 
-type TrustCenterDocumentAccess struct {
-	ID                gid.GID            `json:"id"`
-	Active            bool               `json:"active"`
-	CreatedAt         time.Time          `json:"createdAt"`
-	UpdatedAt         time.Time          `json:"updatedAt"`
-	TrustCenterAccess *TrustCenterAccess `json:"trustCenterAccess"`
-	Document          *Document          `json:"document,omitempty"`
-	Report            *Report            `json:"report,omitempty"`
-	TrustCenterFile   *TrustCenterFile   `json:"trustCenterFile,omitempty"`
-}
-
-func (TrustCenterDocumentAccess) IsNode()             {}
-func (this TrustCenterDocumentAccess) GetID() gid.GID { return this.ID }
-
 type TrustCenterDocumentAccessEdge struct {
 	Cursor page.CursorKey             `json:"cursor"`
 	Node   *TrustCenterDocumentAccess `json:"node"`

pkg/server/api/console/v1/v1_resolver.go

@@ -1439,9 +1439,7 @@ func (r *mutationResolver) UpdateTrustCenterFile(ctx context.Context, input type
 func (r *mutationResolver) GetTrustCenterFile(ctx context.Context, input types.GetTrustCenterFileInput) (*types.GetTrustCenterFilePayload, error) {
 	prb := r.ProboService(ctx, input.ID.TenantID())
 
-	file, err := prb.TrustCenterFiles.Get(ctx, &probo.GetTrustCenterFileRequest{
-		ID: input.ID,
-	})
+	file, err := prb.TrustCenterFiles.Get(ctx, input.ID)
 	if err != nil {
 		return nil, fmt.Errorf("cannot get trust center file: %w", err)
 	}
@@ -4501,6 +4499,13 @@ func (r *queryResolver) Node(ctx context.Context, id gid.GID) (types.Node, error
 		}
 
 		return types.NewTrustCenter(trustCenter, file), nil
+	case coredata.TrustCenterAccessEntityType:
+		trustCenterAccess, err := prb.TrustCenterAccesses.Get(ctx, id)
+		if err != nil {
+			panic(fmt.Errorf("cannot get trust center access: %w", err))
+		}
+
+		return types.NewTrustCenterAccess(trustCenterAccess), nil
 	default:
 	}
 
@@ -4959,8 +4964,32 @@ func (r *trustCenterResolver) References(ctx context.Context, obj *types.TrustCe
 	return types.NewTrustCenterReferenceConnection(result, obj.ID), nil
 }
 
-// DocumentAccesses is the resolver for the documentAccesses field.
-func (r *trustCenterAccessResolver) DocumentAccesses(ctx context.Context, obj *types.TrustCenterAccess, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.OrderBy[coredata.TrustCenterDocumentAccessOrderField]) (*types.TrustCenterDocumentAccessConnection, error) {
+// PendingRequestCount is the resolver for the pendingRequestCount field.
+func (r *trustCenterAccessResolver) PendingRequestCount(ctx context.Context, obj *types.TrustCenterAccess) (int, error) {
+	prb := r.ProboService(ctx, obj.ID.TenantID())
+
+	count, err := prb.TrustCenterAccesses.CountPendingRequestDocumentAccesses(ctx, obj.ID)
+	if err != nil {
+		panic(fmt.Errorf("cannot count pending request document accesses: %w", err))
+	}
+
+	return count, nil
+}
+
+// ActiveCount is the resolver for the activeCount field.
+func (r *trustCenterAccessResolver) ActiveCount(ctx context.Context, obj *types.TrustCenterAccess) (int, error) {
+	prb := r.ProboService(ctx, obj.ID.TenantID())
+
+	count, err := prb.TrustCenterAccesses.CountActiveDocumentAccesses(ctx, obj.ID)
+	if err != nil {
+		panic(fmt.Errorf("cannot count active document accesses: %w", err))
+	}
+
+	return count, nil
+}
+
+// AvailableDocumentAccesses is the resolver for the availableDocumentAccesses field.
+func (r *trustCenterAccessResolver) AvailableDocumentAccesses(ctx context.Context, obj *types.TrustCenterAccess, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.OrderBy[coredata.TrustCenterDocumentAccessOrderField]) (*types.TrustCenterDocumentAccessConnection, error) {
 	prb := r.ProboService(ctx, obj.ID.TenantID())
 
 	pageOrderBy := page.OrderBy[coredata.TrustCenterDocumentAccessOrderField]{
@@ -4976,7 +5005,7 @@ func (r *trustCenterAccessResolver) DocumentAccesses(ctx context.Context, obj *t
 
 	cursor := types.NewCursor(first, after, last, before, pageOrderBy)
 
-	result, err := prb.TrustCenterAccesses.ListDocumentAccesses(ctx, obj.ID, cursor)
+	result, err := prb.TrustCenterAccesses.ListAvailableDocumentAccesses(ctx, obj.ID, cursor)
 	if err != nil {
 		panic(fmt.Errorf("cannot list trust center document accesses: %w", err))
 	}
@@ -4984,26 +5013,15 @@ func (r *trustCenterAccessResolver) DocumentAccesses(ctx context.Context, obj *t
 	return types.NewTrustCenterDocumentAccessConnection(result, obj, obj.ID), nil
 }
 
-// TrustCenterAccess is the resolver for the trustCenterAccess field.
-func (r *trustCenterDocumentAccessResolver) TrustCenterAccess(ctx context.Context, obj *types.TrustCenterDocumentAccess) (*types.TrustCenterAccess, error) {
-	// The TrustCenterAccess is already loaded from the connection resolver
-	return obj.TrustCenterAccess, nil
-}
-
 // Document is the resolver for the document field.
 func (r *trustCenterDocumentAccessResolver) Document(ctx context.Context, obj *types.TrustCenterDocumentAccess) (*types.Document, error) {
-	prb := r.ProboService(ctx, obj.ID.TenantID())
-
-	documentAccess, err := prb.TrustCenterAccesses.GetDocumentAccess(ctx, obj.ID)
-	if err != nil {
-		return nil, fmt.Errorf("cannot load trust center document access: %w", err)
-	}
-
-	if documentAccess.DocumentID == nil {
+	if obj.DocumentID == nil {
 		return nil, nil
 	}
 
-	document, err := prb.Documents.Get(ctx, *documentAccess.DocumentID)
+	prb := r.ProboService(ctx, obj.ID.TenantID())
+
+	document, err := prb.Documents.Get(ctx, *obj.DocumentID)
 	if err != nil {
 		return nil, fmt.Errorf("cannot load document: %w", err)
 	}
@@ -5013,18 +5031,13 @@ func (r *trustCenterDocumentAccessResolver) Document(ctx context.Context, obj *t
 
 // Report is the resolver for the report field.
 func (r *trustCenterDocumentAccessResolver) Report(ctx context.Context, obj *types.TrustCenterDocumentAccess) (*types.Report, error) {
-	prb := r.ProboService(ctx, obj.ID.TenantID())
-
-	documentAccess, err := prb.TrustCenterAccesses.GetDocumentAccess(ctx, obj.ID)
-	if err != nil {
-		return nil, fmt.Errorf("cannot load trust center document access: %w", err)
-	}
-
-	if documentAccess.ReportID == nil {
+	if obj.ReportID == nil {
 		return nil, nil
 	}
 
-	report, err := prb.Reports.Get(ctx, *documentAccess.ReportID)
+	prb := r.ProboService(ctx, obj.ID.TenantID())
+
+	report, err := prb.Reports.Get(ctx, *obj.ReportID)
 	if err != nil {
 		return nil, fmt.Errorf("cannot load report: %w", err)
 	}
@@ -5034,20 +5047,13 @@ func (r *trustCenterDocumentAccessResolver) Report(ctx context.Context, obj *typ
 
 // TrustCenterFile is the resolver for the trustCenterFile field.
 func (r *trustCenterDocumentAccessResolver) TrustCenterFile(ctx context.Context, obj *types.TrustCenterDocumentAccess) (*types.TrustCenterFile, error) {
-	prb := r.ProboService(ctx, obj.ID.TenantID())
-
-	documentAccess, err := prb.TrustCenterAccesses.GetDocumentAccess(ctx, obj.ID)
-	if err != nil {
-		return nil, fmt.Errorf("cannot load trust center document access: %w", err)
-	}
-
-	if documentAccess.TrustCenterFileID == nil {
+	if obj.TrustCenterFileID == nil {
 		return nil, nil
 	}
 
-	trustCenterFile, err := prb.TrustCenterFiles.Get(ctx, &probo.GetTrustCenterFileRequest{
-		ID: *documentAccess.TrustCenterFileID,
-	})
+	prb := r.ProboService(ctx, obj.ID.TenantID())
+
+	trustCenterFile, err := prb.TrustCenterFiles.Get(ctx, *obj.TrustCenterFileID)
 	if err != nil {
 		return nil, fmt.Errorf("cannot load trust center file: %w", err)
 	}
@@ -5083,9 +5089,7 @@ func (r *trustCenterFileResolver) FileURL(ctx context.Context, obj *types.TrustC
 func (r *trustCenterFileResolver) Organization(ctx context.Context, obj *types.TrustCenterFile) (*types.Organization, error) {
 	prb := r.ProboService(ctx, obj.ID.TenantID())
 
-	file, err := prb.TrustCenterFiles.Get(ctx, &probo.GetTrustCenterFileRequest{
-		ID: obj.ID,
-	})
+	file, err := prb.TrustCenterFiles.Get(ctx, obj.ID)
 	if err != nil {
 		panic(fmt.Errorf("cannot get trust center file: %w", err))
 	}

pkg/trust/trust_center_access_service.go

@@ -208,15 +208,15 @@ func (s TrustCenterAccessService) Request(
 
 		var accesses coredata.TrustCenterDocumentAccesses
 
-		if err := accesses.BulkInsertDocumentAccesses(ctx, tx, s.svc.scope, access.ID, newDocumentIDs, now); err != nil {
+		if err := accesses.BulkInsertDocumentAccesses(ctx, tx, s.svc.scope, access.ID, newDocumentIDs, true, now); err != nil {
 			return fmt.Errorf("cannot bulk insert trust center document accesses: %w", err)
 		}
 
-		if err := accesses.BulkInsertReportAccesses(ctx, tx, s.svc.scope, access.ID, newReportIDs, now); err != nil {
+		if err := accesses.BulkInsertReportAccesses(ctx, tx, s.svc.scope, access.ID, newReportIDs, true, now); err != nil {
 			return fmt.Errorf("cannot bulk insert trust center report accesses: %w", err)
 		}
 
-		if err := accesses.BulkInsertTrustCenterFileAccesses(ctx, tx, s.svc.scope, access.ID, newTrustCenterFileIDs, now); err != nil {
+		if err := accesses.BulkInsertTrustCenterFileAccesses(ctx, tx, s.svc.scope, access.ID, newTrustCenterFileIDs, true, now); err != nil {
 			return fmt.Errorf("cannot bulk insert trust center file accesses: %w", err)
 		}
 
@@ -409,7 +409,7 @@ func (s *TrustCenterAccessService) AcceptByIDs(
 			return fmt.Errorf("cannot load trust center access: %w", err)
 		}
 
-		wasInactive := !access.Active
+		shouldSendEmail := !access.Active
 		now := time.Now()
 
 		if len(documentIDs) > 0 {
@@ -428,7 +428,7 @@ func (s *TrustCenterAccessService) AcceptByIDs(
 			}
 		}
 
-		if wasInactive {
+		if shouldSendEmail {
 			access.Active = true
 			access.UpdatedAt = now
 			if err := access.Update(ctx, tx, s.svc.scope); err != nil {
@@ -496,6 +496,15 @@ func (s *TrustCenterAccessService) sendAccessEmail(ctx context.Context, tx pg.Co
 		}.Encode(),
 	}
 
+	now := time.Now()
+	expiresAt := now.Add(s.svc.trustConfig.TokenDuration)
+	access.LastTokenExpiresAt = &expiresAt
+	access.UpdatedAt = now
+
+	if err := access.Update(ctx, tx, s.svc.scope); err != nil {
+		return fmt.Errorf("cannot update trust center access with expiration: %w", err)
+	}
+
 	return s.sendTrustCenterAccessEmail(ctx, tx, access.Name, access.Email, organization.Name, accessURL.String())
 }
 
@@ -512,6 +521,7 @@ func (s *TrustCenterAccessService) sendTrustCenterAccessEmail(
 		name,
 		companyName,
 		accessURL,
+		s.svc.trustConfig.TokenDuration,
 	)
 	if err != nil {
 		return fmt.Errorf("cannot render trust center access email: %w", err)