feat(storage): add native PostgreSQL runtime and verified offline application import
Build and publish container images / images (push) Failing after 12m29s

This commit is contained in:
Anya Tokugawa committed 2026-11-15 05:47:14 +09:00
1 parent 96065d1e89
commit 0ba1dcfef0
243 files changed
+21441 -3090

No files matched your search

+94 -72
View File
@@ -1,6 +1,7 @@
package store
import (
"context"
"crypto/sha256"
"database/sql"
"encoding/base64"
@@ -134,25 +135,19 @@ func (s *Store) BindExternalIdentityIfProviderUnbound(domainUUID, principalUUID,
if err != nil {
return err
}
tx, err := s.DB.Begin()
if err != nil {
return err
}
defer tx.Rollback()
if _, err = tx.Exec(`UPDATE principals SET updated_at_ms=updated_at_ms WHERE uuid=?`, principalUUID); err != nil {
return err
}
var eligible, alreadyBound bool
if err = tx.QueryRow(`SELECT EXISTS(SELECT 1 FROM principals p JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=? AND m.state='active' WHERE p.uuid=? AND p.state IN ('active','readonly'))`, domainUUID, principalUUID).Scan(&eligible); err != nil || !eligible {
return ErrAccessDenied
}
if err = tx.QueryRow(`SELECT EXISTS(SELECT 1 FROM principal_identities WHERE principal_uuid=? AND provider_type=? AND provider_uuid=?)`, principalUUID, providerType, providerUUID).Scan(&alreadyBound); err != nil || alreadyBound {
return ErrAccessDenied
}
if _, err = tx.Exec(`INSERT INTO principal_identities(uuid,principal_uuid,provider_type,provider_uuid,issuer,subject,attributes_json,created_at_ms) VALUES(?,?,?,?,?,?,?,?)`, uuid.NewString(), principalUUID, providerType, providerUUID, issuer, subject, payload, time.Now().UnixMilli()); err != nil {
return ErrAccessDenied
}
return tx.Commit()
return s.groupWrite(context.Background(), func(ctx context.Context, tx *sql.Tx) error {
var eligible, alreadyBound bool
if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM principals p JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=`+s.sqlParam(1)+` AND m.state='active' WHERE p.uuid=`+s.sqlParam(2)+` AND p.state IN ('active','readonly'))`, domainUUID, principalUUID).Scan(&eligible); err != nil || !eligible {
return ErrAccessDenied
}
if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM principal_identities WHERE principal_uuid=`+s.sqlParam(1)+` AND provider_type=`+s.sqlParam(2)+` AND provider_uuid=`+s.sqlParam(3)+`)`, principalUUID, providerType, providerUUID).Scan(&alreadyBound); err != nil || alreadyBound {
return ErrAccessDenied
}
if _, err = tx.ExecContext(ctx, `INSERT INTO principal_identities(uuid,principal_uuid,provider_type,provider_uuid,issuer,subject,attributes_json,created_at_ms) VALUES(`+s.sqlValues(8)+`)`, uuid.NewString(), principalUUID, providerType, providerUUID, issuer, subject, payload, time.Now().UnixMilli()); err != nil {
return ErrAccessDenied
}
return nil
})
}
// ProvisionExternalAccount creates a normal Domain member with a local
@@ -172,42 +167,49 @@ func (s *Store) ProvisionExternalAccount(domainUUID, username, displayName, emai
if p.DisplayName == "" {
p.DisplayName = username
}
tx, err := s.DB.Begin()
err = s.groupWrite(context.Background(), func(ctx context.Context, tx *sql.Tx) error {
if s.sqlBackend == storePostgreSQL {
var present bool
if err := tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM domains WHERE uuid=$1 AND enabled=1 AND placement='local')`, domainUUID).Scan(&present); err != nil {
return err
}
if !present {
return sql.ErrNoRows
}
}
roleID := ""
err = tx.QueryRowContext(ctx, `SELECT uuid FROM auth_roles WHERE domain_uuid=`+s.sqlParam(1)+` AND name='member'`, domainUUID).Scan(&roleID)
if errors.Is(err, sql.ErrNoRows) {
roleID = uuid.NewString()
if _, err = tx.ExecContext(ctx, `INSERT INTO auth_roles(uuid,domain_uuid,name,description,created_at_ms) VALUES(`+s.sqlValues(5)+`)`, roleID, domainUUID, "member", "Domain member", now); err != nil {
return err
}
if _, err = tx.ExecContext(ctx, `INSERT INTO auth_capability_grants(uuid,role_uuid,capability,target_type,target_id,created_at_ms) VALUES(`+s.sqlValues(6)+`)`, uuid.NewString(), roleID, "read", "domain", domainUUID, now); err != nil {
return err
}
} else if err != nil {
return err
}
membershipID := uuid.NewString()
for _, item := range []struct {
query string
args []any
}{
{`INSERT INTO principals(uuid,display_name,email,state,created_at_ms,updated_at_ms) VALUES(` + s.sqlValues(6) + `)`, []any{p.UUID, p.DisplayName, p.Email, p.State, now, now}},
{`INSERT INTO principal_identities(uuid,principal_uuid,provider_type,subject,created_at_ms) VALUES(` + s.sqlValues(5) + `)`, []any{uuid.NewString(), p.UUID, "password", username, now}},
{`INSERT INTO principal_identities(uuid,principal_uuid,provider_type,provider_uuid,issuer,subject,attributes_json,created_at_ms) VALUES(` + s.sqlValues(8) + `)`, []any{uuid.NewString(), p.UUID, providerType, providerUUID, issuer, subject, payload, now}},
{`INSERT INTO domain_memberships(uuid,domain_uuid,principal_uuid,state,created_at_ms) VALUES(` + s.sqlValues(5) + `)`, []any{membershipID, domainUUID, p.UUID, "active", now}},
{`INSERT INTO auth_role_bindings(membership_uuid,role_uuid,created_at_ms) VALUES(` + s.sqlValues(3) + `)`, []any{membershipID, roleID, now}},
} {
if _, err = tx.ExecContext(ctx, item.query, item.args...); err != nil {
return ErrAccessDenied
}
}
return nil
})
if err != nil {
return nil, err
}
defer tx.Rollback()
roleID := ""
err = tx.QueryRow(`SELECT uuid FROM auth_roles WHERE domain_uuid=? AND name='member'`, domainUUID).Scan(&roleID)
if errors.Is(err, sql.ErrNoRows) {
roleID = uuid.NewString()
if _, err = tx.Exec(`INSERT INTO auth_roles(uuid,domain_uuid,name,description,created_at_ms) VALUES(?,?,?,?,?)`, roleID, domainUUID, "member", "Domain member", now); err != nil {
return nil, err
}
if _, err = tx.Exec(`INSERT INTO auth_capability_grants(uuid,role_uuid,capability,target_type,target_id,created_at_ms) VALUES(?,?,?,?,?,?)`, uuid.NewString(), roleID, "read", "domain", domainUUID, now); err != nil {
return nil, err
}
} else if err != nil {
return nil, err
}
membershipID := uuid.NewString()
for _, item := range []struct {
query string
args []any
}{
{`INSERT INTO principals(uuid,display_name,email,state,created_at_ms,updated_at_ms) VALUES(?,?,?,?,?,?)`, []any{p.UUID, p.DisplayName, p.Email, p.State, now, now}},
{`INSERT INTO principal_identities(uuid,principal_uuid,provider_type,subject,created_at_ms) VALUES(?,?,?,?,?)`, []any{uuid.NewString(), p.UUID, "password", username, now}},
{`INSERT INTO principal_identities(uuid,principal_uuid,provider_type,provider_uuid,issuer,subject,attributes_json,created_at_ms) VALUES(?,?,?,?,?,?,?,?)`, []any{uuid.NewString(), p.UUID, providerType, providerUUID, issuer, subject, payload, now}},
{`INSERT INTO domain_memberships(uuid,domain_uuid,principal_uuid,state,created_at_ms) VALUES(?,?,?,?,?)`, []any{membershipID, domainUUID, p.UUID, "active", now}},
{`INSERT INTO auth_role_bindings(membership_uuid,role_uuid,created_at_ms) VALUES(?,?,?)`, []any{membershipID, roleID, now}},
} {
if _, err = tx.Exec(item.query, item.args...); err != nil {
return nil, ErrAccessDenied
}
}
if err = tx.Commit(); err != nil {
return nil, err
}
return p, nil
}
@@ -248,20 +250,23 @@ func (s *Store) SetAuthProviderConfig(domainUUID string, config AuthProviderConf
if err != nil {
return err
}
} else {
_ = s.DB.QueryRow(`SELECT secret_encrypted FROM auth_providers WHERE domain_uuid=? AND kind=?`, domainUUID, config.Kind).Scan(&encrypted)
}
_, err = s.DB.Exec(`INSERT INTO auth_providers(uuid,domain_uuid,kind,config_json,secret_encrypted,enabled,created_at_ms,updated_at_ms) VALUES(?,?,?,?,?,?,?,?) ON CONFLICT(domain_uuid,kind) DO UPDATE SET config_json=excluded.config_json,secret_encrypted=excluded.secret_encrypted,enabled=excluded.enabled,updated_at_ms=excluded.updated_at_ms`, uuid.NewString(), domainUUID, config.Kind, string(payload), encrypted, config.Enabled, time.Now().UnixMilli(), time.Now().UnixMilli())
return err
enabled := 0
if config.Enabled {
enabled = 1
}
// Preserve the current secret inside the UPSERT, not via a stale pre-read.
_, err = s.DB.Exec(`INSERT INTO auth_providers(uuid,domain_uuid,kind,config_json,secret_encrypted,enabled,created_at_ms,updated_at_ms) VALUES(`+s.sqlValues(8)+`) ON CONFLICT(domain_uuid,kind) DO UPDATE SET config_json=excluded.config_json,secret_encrypted=CASE WHEN excluded.secret_encrypted='' THEN auth_providers.secret_encrypted ELSE excluded.secret_encrypted END,enabled=excluded.enabled,updated_at_ms=excluded.updated_at_ms`, uuid.NewString(), domainUUID, config.Kind, string(payload), encrypted, enabled, time.Now().UnixMilli(), time.Now().UnixMilli())
return s.sqlError("auth provider update", err)
}
func (s *Store) AuthProviderConfig(domainUUID, kind string) (AuthProviderConfig, error) {
var config AuthProviderConfig
var payload, encrypted string
var enabled bool
err := s.DB.QueryRow(`SELECT uuid,config_json,secret_encrypted,enabled FROM auth_providers WHERE domain_uuid=? AND kind=?`, domainUUID, kind).Scan(&config.UUID, &payload, &encrypted, &enabled)
err := s.DB.QueryRow(`SELECT uuid,config_json,secret_encrypted,enabled FROM auth_providers WHERE domain_uuid=`+s.sqlParam(1)+` AND kind=`+s.sqlParam(2)+``, domainUUID, kind).Scan(&config.UUID, &payload, &encrypted, &enabled)
if err != nil {
return config, err
return config, s.sqlError("auth provider lookup", err)
}
if err := json.Unmarshal([]byte(payload), &config); err != nil {
return config, err
@@ -304,8 +309,8 @@ func (s *Store) PrincipalByExternalUsername(domainUUID, username string) (*Princ
}
rows, err := s.DB.Query(`SELECT p.uuid,i.subject,p.display_name,p.email,p.state,length(p.avatar)>0
FROM principal_identities i JOIN principals p ON p.uuid=i.principal_uuid
JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=? AND m.state='active'
WHERE i.provider_type='password' AND i.subject=? AND p.state IN ('active','readonly') LIMIT 2`, domainUUID, username)
JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=`+s.sqlParam(1)+` AND m.state='active'
WHERE i.provider_type='password' AND i.subject=`+s.sqlParam(2)+` AND p.state IN ('active','readonly') LIMIT 2`, domainUUID, username)
if err != nil {
return nil, err
}
@@ -335,7 +340,7 @@ func (s *Store) PrincipalByVerifiedEmail(domainUUID, email string) (*Principal,
if email == "" || domainUUID == "" {
return nil, ErrAccessDenied
}
rows, err := s.DB.Query(`SELECT p.uuid,COALESCE((SELECT subject FROM principal_identities i WHERE i.principal_uuid=p.uuid AND i.provider_type='password' LIMIT 1),p.uuid),p.display_name,p.email,p.state,length(p.avatar)>0 FROM principals p JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=? AND m.state='active' WHERE lower(p.email)=? AND p.state IN ('active','readonly') LIMIT 2`, domainUUID, email)
rows, err := s.DB.Query(`SELECT p.uuid,COALESCE((SELECT subject FROM principal_identities i WHERE i.principal_uuid=p.uuid AND i.provider_type='password' ORDER BY subject,uuid LIMIT 1),p.uuid),p.display_name,p.email,p.state,length(p.avatar)>0 FROM principals p JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=`+s.sqlParam(1)+` AND m.state='active' WHERE lower(p.email)=`+s.sqlParam(2)+` AND p.state IN ('active','readonly') LIMIT 2`, domainUUID, email)
if err != nil {
return nil, err
}
@@ -370,11 +375,11 @@ func (s *Store) PrincipalByDisplayName(domainUUID, displayName string) (*Princip
return nil, ErrAccessDenied
}
rows, err := s.DB.Query(`SELECT p.uuid,
COALESCE((SELECT subject FROM principal_identities i WHERE i.principal_uuid=p.uuid AND i.provider_type='password' LIMIT 1),p.uuid),
COALESCE((SELECT subject FROM principal_identities i WHERE i.principal_uuid=p.uuid AND i.provider_type='password' ORDER BY subject,uuid LIMIT 1),p.uuid),
p.display_name,p.email,p.state,length(p.avatar)>0
FROM principals p JOIN domain_memberships m
ON m.principal_uuid=p.uuid AND m.domain_uuid=? AND m.state='active'
WHERE p.display_name=? AND p.state IN ('active','readonly') LIMIT 2`, domainUUID, displayName)
ON m.principal_uuid=p.uuid AND m.domain_uuid=`+s.sqlParam(1)+` AND m.state='active'
WHERE p.display_name=`+s.sqlParam(2)+` AND p.state IN ('active','readonly') LIMIT 2`, domainUUID, displayName)
if err != nil {
return nil, err
}
@@ -408,7 +413,7 @@ func (s *Store) BindExternalIdentity(principalUUID, providerType, providerUUID,
return err
}
now := time.Now().UnixMilli()
result, err := s.DB.Exec(`INSERT INTO principal_identities(uuid,principal_uuid,provider_type,provider_uuid,issuer,subject,attributes_json,created_at_ms) VALUES(?,?,?,?,?,?,?,?) ON CONFLICT(provider_type,provider_uuid,issuer,subject) DO UPDATE SET attributes_json=excluded.attributes_json WHERE principal_identities.principal_uuid=excluded.principal_uuid`, uuid.NewString(), principalUUID, providerType, providerUUID, issuer, subject, string(payload), now)
result, err := s.DB.Exec(`INSERT INTO principal_identities(uuid,principal_uuid,provider_type,provider_uuid,issuer,subject,attributes_json,created_at_ms) VALUES(`+s.sqlValues(8)+`) ON CONFLICT(provider_type,provider_uuid,issuer,subject) DO UPDATE SET attributes_json=excluded.attributes_json WHERE principal_identities.principal_uuid=excluded.principal_uuid`, uuid.NewString(), principalUUID, providerType, providerUUID, issuer, subject, string(payload), now)
if err != nil {
return err
}
@@ -424,7 +429,7 @@ func (s *Store) BindExternalIdentity(principalUUID, providerType, providerUUID,
func (s *Store) PrincipalByExternalIdentity(domainUUID, providerType, providerUUID, issuer, subject string) (*Principal, error) {
var p Principal
err := s.DB.QueryRow(`SELECT p.uuid,COALESCE((SELECT subject FROM principal_identities x WHERE x.principal_uuid=p.uuid AND x.provider_type='password' LIMIT 1),p.uuid),p.display_name,p.email,p.state,length(p.avatar)>0 FROM principal_identities i JOIN principals p ON p.uuid=i.principal_uuid JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=? AND m.state='active' WHERE i.provider_type=? AND i.provider_uuid=? AND i.issuer=? AND i.subject=? AND p.state IN ('active','readonly')`, domainUUID, providerType, providerUUID, issuer, subject).Scan(&p.UUID, &p.Username, &p.DisplayName, &p.Email, &p.State, &p.HasAvatar)
err := s.DB.QueryRow(`SELECT p.uuid,COALESCE((SELECT subject FROM principal_identities x WHERE x.principal_uuid=p.uuid AND x.provider_type='password' ORDER BY subject,uuid LIMIT 1),p.uuid),p.display_name,p.email,p.state,length(p.avatar)>0 FROM principal_identities i JOIN principals p ON p.uuid=i.principal_uuid JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=`+s.sqlParam(1)+` AND m.state='active' WHERE i.provider_type=`+s.sqlParam(2)+` AND i.provider_uuid=`+s.sqlParam(3)+` AND i.issuer=`+s.sqlParam(4)+` AND i.subject=`+s.sqlParam(5)+` AND p.state IN ('active','readonly')`, domainUUID, providerType, providerUUID, issuer, subject).Scan(&p.UUID, &p.Username, &p.DisplayName, &p.Email, &p.State, &p.HasAvatar)
return &p, err
}
@@ -433,23 +438,29 @@ func (s *Store) CreateAuthChallenge(domainUUID, principalUUID, kind string, payl
if err != nil {
return "", err
}
encoded, _ := json.Marshal(payload)
encoded, err := json.Marshal(payload)
if err != nil {
return "", err
}
now := time.Now().UnixMilli()
_, err = s.DB.Exec(`INSERT INTO auth_challenges(uuid,domain_uuid,principal_uuid,kind,token_hash,payload_json,expires_at_ms,created_at_ms) VALUES(?,?,?,?,?,?,?,?)`, uuid.NewString(), domainUUID, principalUUID, kind, hash, string(encoded), now+lifetime.Milliseconds(), now)
return token, err
_, err = s.DB.Exec(`INSERT INTO auth_challenges(uuid,domain_uuid,principal_uuid,kind,token_hash,payload_json,expires_at_ms,created_at_ms) VALUES(`+s.sqlValues(8)+`)`, uuid.NewString(), domainUUID, principalUUID, kind, hash, string(encoded), now+lifetime.Milliseconds(), now)
if err != nil {
return "", s.sqlError("auth challenge creation", err)
}
return token, nil
}
func (s *Store) ConsumeAuthChallenge(domainUUID, kind, token string, payload any) (string, error) {
hash := hashAuthToken(token)
var id, principalUUID, encoded string
var expires int64
err := s.DB.QueryRow(`SELECT uuid,principal_uuid,payload_json,expires_at_ms FROM auth_challenges WHERE domain_uuid=? AND kind=? AND token_hash=? AND consumed_at_ms=0`, domainUUID, kind, hash).Scan(&id, &principalUUID, &encoded, &expires)
err := s.DB.QueryRow(`SELECT uuid,principal_uuid,payload_json,expires_at_ms FROM auth_challenges WHERE domain_uuid=`+s.sqlParam(1)+` AND kind=`+s.sqlParam(2)+` AND token_hash=`+s.sqlParam(3)+` AND consumed_at_ms=0`, domainUUID, kind, hash).Scan(&id, &principalUUID, &encoded, &expires)
if err != nil || expires < time.Now().UnixMilli() {
return "", ErrAccessDenied
}
result, err := s.DB.Exec(`UPDATE auth_challenges SET consumed_at_ms=? WHERE uuid=? AND consumed_at_ms=0`, time.Now().UnixMilli(), id)
result, err := s.DB.Exec(`UPDATE auth_challenges SET consumed_at_ms=`+s.sqlParam(1)+` WHERE uuid=`+s.sqlParam(2)+` AND consumed_at_ms=0 AND expires_at_ms>`+s.sqlParam(3), time.Now().UnixMilli(), id, time.Now().UnixMilli())
if err != nil {
return "", err
return "", s.sqlError("auth challenge consumption", err)
}
changed, _ := result.RowsAffected()
if changed != 1 {
@@ -461,6 +472,17 @@ func (s *Store) ConsumeAuthChallenge(domainUUID, kind, token string, payload any
return principalUUID, nil
}
// A consumed link does not authorize a changed email address or a disabled
// membership. Keep the HTTP layer independent of the SQL placeholder dialect.
func (s *Store) ValidateMagicLinkIdentity(ctx context.Context, domain, principal, email string) (bool, error) {
if email == "" {
return false, nil
}
var valid bool
err := s.DB.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM principals p JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=`+s.sqlParam(1)+` WHERE p.uuid=`+s.sqlParam(2)+` AND p.state IN ('active','readonly') AND m.state='active' AND p.email=`+s.sqlParam(3)+`)`, domain, principal, email).Scan(&valid)
return err == nil && valid, s.sqlError("magic link identity", err)
}
func hashAuthToken(token string) string {
sum := sha256.Sum256([]byte(token))
return base64.RawURLEncoding.EncodeToString(sum[:])