Files
archie/internal/infrastructure/postgres/harness_secrets.go
T
sam 63229d1711 refactor(storecontract): assert every store interface at its implementation (#1781)
Complete the var _ storecontract.X = (*T)(nil) sweep so each of the 31
contract interfaces is compiler-checked against at least one adapter:
postgres.Store (19), postgres.EDA (11, consolidated into edastore.go),
staterpc.Client (29). Removes the scattered single-line assertions from
harness_secrets.go, edastore_eventtypes.go, sources.go, run_credentials.go.
task check green.
2026-11-03 06:24:09 +11:00

130 lines
4.5 KiB
Go

package postgres
import (
"context"
"encoding/json"
"errors"
"fmt"
"time"
"github.com/jackc/pgx/v5"
"github.com/samcharles93/archie-core/internal/domain/harnesssecret"
"github.com/samcharles93/archie-core/internal/domain/storecontract"
"github.com/samcharles93/archie-core/internal/infrastructure/bindingcipher"
"github.com/samcharles93/archie-core/internal/infrastructure/postgres/postgresdb"
)
// harnessSecretPayload is the JSON shape sealed into harness_secrets.secret_enc:
// the whole token set behind one envelope, never separate plaintext columns.
type harnessSecretPayload struct {
AccessToken string `json:"access_token"`
RefreshToken string `json:"refresh_token"`
TokenType string `json:"token_type"`
ExpiresAt time.Time `json:"expires_at"`
Scopes []string `json:"scopes,omitempty"`
}
// GetHarnessSecret returns the stored OAuth token set for an org/service
// credential binding, or storecontract.ErrHarnessSecretNotFound.
func (s *EDA) GetHarnessSecret(ctx context.Context, org, service string) (harnesssecret.Secret, error) {
row, err := s.q.GetHarnessSecret(ctx, postgresdb.GetHarnessSecretParams{Org: org, Service: service})
if errors.Is(err, pgx.ErrNoRows) {
return harnesssecret.Secret{}, storecontract.ErrHarnessSecretNotFound
}
if err != nil {
return harnesssecret.Secret{}, fmt.Errorf("postgres: get harness secret: %w", err)
}
payload, err := s.openHarnessSecret(row.SecretEnc)
if err != nil {
return harnesssecret.Secret{}, err
}
return harnesssecret.Secret{
Org: row.Org, Service: row.Service,
AccessToken: payload.AccessToken, RefreshToken: payload.RefreshToken,
TokenType: payload.TokenType, ExpiresAt: payload.ExpiresAt,
Scopes: payload.Scopes,
UpdatedAt: row.UpdatedAt,
}, nil
}
// PutHarnessSecret upserts an org/service credential binding's OAuth token
// set. Called by the setup terminal's first capture and by the egress
// proxy's every refresh.
func (s *EDA) PutHarnessSecret(ctx context.Context, secret harnesssecret.Secret) error {
if err := secret.Validate(); err != nil {
return err
}
sealed, err := s.sealHarnessSecret(harnessSecretPayload{
AccessToken: secret.AccessToken, RefreshToken: secret.RefreshToken,
TokenType: secret.TokenType, ExpiresAt: secret.ExpiresAt,
Scopes: secret.Scopes,
})
if err != nil {
return err
}
tx, err := s.pool.Begin(ctx)
if err != nil {
return err
}
defer func() { _ = tx.Rollback(ctx) }()
q := postgresdb.New(tx)
inserted, err := q.PutHarnessSecret(ctx, postgresdb.PutHarnessSecretParams{
Org: secret.Org, Service: secret.Service, SecretEnc: sealed,
})
if err != nil {
return fmt.Errorf("postgres: put harness secret: %w", err)
}
// The trail records that the credential changed, never any part of it: no
// access token, refresh token or ciphertext. The insert flag is read by the
// same statement, so a concurrent first capture is an update, not a second
// create. A first capture has a nil old side.
var oldValue []byte
if !inserted {
if oldValue, err = auditJSON(map[string]bool{"changed": true}); err != nil {
return err
}
}
newValue, err := auditJSON(map[string]bool{"changed": true})
if err != nil {
return err
}
if err := insertAudit(ctx, q, "harness_secrets", secret.Service, "credential", oldValue, newValue, 0, secret.Org); err != nil {
return err
}
return tx.Commit(ctx)
}
// sealHarnessSecret encrypts the token set under HarnessSecretDomain. An
// encryption key is required.
func (s *EDA) sealHarnessSecret(payload harnessSecretPayload) (string, error) {
if s.cipher == nil {
return "", errors.New("postgres: harness secrets require an encryption key")
}
raw, err := json.Marshal(payload)
if err != nil {
return "", fmt.Errorf("postgres: marshal harness secret: %w", err)
}
sealed, err := s.cipher.EncryptDomain(bindingcipher.HarnessSecretDomain, string(raw))
if err != nil {
return "", fmt.Errorf("postgres: encrypt harness secret: %w", err)
}
return sealed, nil
}
// openHarnessSecret reverses sealHarnessSecret.
func (s *EDA) openHarnessSecret(stored string) (harnessSecretPayload, error) {
if s.cipher == nil {
return harnessSecretPayload{}, errors.New("postgres: harness secrets require an encryption key")
}
raw, err := s.cipher.DecryptDomain(bindingcipher.HarnessSecretDomain, stored)
if err != nil {
return harnessSecretPayload{}, fmt.Errorf("postgres: decrypt harness secret: %w", err)
}
var payload harnessSecretPayload
if err := json.Unmarshal([]byte(raw), &payload); err != nil {
return harnessSecretPayload{}, fmt.Errorf("postgres: unmarshal harness secret: %w", err)
}
return payload, nil
}