package postgres import ( "context" "errors" "fmt" "strings" "time" "github.com/jackc/pgx/v5" "github.com/jackc/pgx/v5/pgtype" "github.com/samcharles93/archie-core/internal/domain/identity" "github.com/samcharles93/archie-core/internal/domain/org" "github.com/samcharles93/archie-core/internal/infrastructure/postgres/postgresdb" ) // identityFromRow maps the generated identity row to the domain identity. func identityFromRow(i postgresdb.Identity) identity.Identity { return identity.Identity{ ID: identity.IdentityID(i.ID), Kind: identity.Kind(i.Kind), DisplayName: i.DisplayName, Lifecycle: identity.Lifecycle(i.Lifecycle), Version: i.Version, CreatedAt: i.CreatedAt, UpdatedAt: i.UpdatedAt, } } // insertIdentityEvent writes one identity audit event under the subject's own // org, not the actor's: an org-sys operator suspending an org A member must // not file that event under org-sys. fallback is used when the identity has no // org yet, as on a create that has not been assigned one. func insertIdentityEvent(ctx context.Context, q *postgresdb.Queries, fallback org.OrgID, id identity.IdentityID, ev identity.Event, audit identity.Audit, at time.Time) error { orgID, err := auditSubjectOrg(ctx, q, fallback, id) if err != nil { return err } return writeIdentityEvent(ctx, q, orgID, id, ev, audit, at) } // insertIdentityEventInOrg records an event under a target org the caller // already knows, without resolving the subject's orgs. Account signup uses it: // the account's new org is the target, whoever else the person already belongs // to. func insertIdentityEventInOrg(ctx context.Context, q *postgresdb.Queries, orgID org.OrgID, id identity.IdentityID, ev identity.Event, audit identity.Audit, at time.Time) error { return writeIdentityEvent(ctx, q, orgID, id, ev, audit, at) } // auditSubjectOrg is the one definition of an identity event's org. A subject // in exactly one org is attributed to it whatever org the actor acts in; a // subject in two or more is deliberately unattributed (NULL), because picking // one would hide the event from the other org's feed. An identity with no org // yet uses fallback, the acting org. func auditSubjectOrg(ctx context.Context, q *postgresdb.Queries, fallback org.OrgID, id identity.IdentityID) (org.OrgID, error) { single, err := q.IdentityAuditOrg(ctx, string(id)) if errors.Is(err, pgx.ErrNoRows) { return fallback, nil } if err != nil { return "", fmt.Errorf("identity audit org: %w", err) } return org.OrgID(single), nil } // writeIdentityEvent records the event under orgID. An empty org is stored as // NULL, which the audit feed shows only to instance administrators. func writeIdentityEvent(ctx context.Context, q *postgresdb.Queries, orgID org.OrgID, id identity.IdentityID, ev identity.Event, audit identity.Audit, at time.Time) error { if audit.ActorID == "" || audit.Source == "" || audit.RequestID == "" { return fmt.Errorf("%w: audit actor, source, and request ID are required", identity.ErrInvalid) } storedOrg := pgtype.Text{} if orgID != "" { storedOrg = pgtype.Text{String: string(orgID), Valid: true} } return q.InsertIdentityEvent(ctx, postgresdb.InsertIdentityEventParams{ IdentityID: string(id), EventType: string(ev.Type), FromLifecycle: string(ev.From), ToLifecycle: string(ev.To), DisplayName: ev.DisplayName, ActorID: string(audit.ActorID), Source: audit.Source, RequestID: audit.RequestID, At: at, OrgID: storedOrg, }) } // List returns every identity the request's scope may see, oldest first. func (s *Store) List(ctx context.Context) ([]identity.Identity, error) { rows, err := s.queries().ListIdentities(ctx, memberScope(ctx)) if err != nil { return nil, err } out := make([]identity.Identity, 0, len(rows)) for _, r := range rows { out = append(out, identityFromRow(r)) } return out, nil } // Get returns one identity by id, or ErrNotFound when there is none the // request's scope may see. func (s *Store) Get(ctx context.Context, id identity.IdentityID) (identity.Identity, error) { i, err := s.queries().GetVisibleIdentity(ctx, postgresdb.GetVisibleIdentityParams{ID: string(id), ScopeOrg: memberScope(ctx)}) if errors.Is(err, pgx.ErrNoRows) { return identity.Identity{}, identity.ErrNotFound } if err != nil { return identity.Identity{}, err } return identityFromRow(i), nil } // ResolveLegacyName resolves a legacy display name through the aliases table. // Aliases match case-insensitively, mirroring the SQLite schema's COLLATE // NOCASE. func (s *Store) ResolveLegacyName(ctx context.Context, name string) (identity.Identity, error) { i, err := s.queries().ResolveIdentityAlias(ctx, postgresdb.ResolveIdentityAliasParams{Alias: strings.TrimSpace(name), ScopeOrg: memberScope(ctx)}) if errors.Is(err, pgx.ErrNoRows) { return identity.Identity{}, identity.ErrNotFound } if err != nil { return identity.Identity{}, err } return identityFromRow(i), nil } // Create inserts a new identity, its display-name alias and its create audit // event in one transaction. An agent is assigned in the same transaction to // the org the request acts in, with the shipped developer role, so it is // authorized as soon as it exists. func (s *Store) Create(ctx context.Context, value identity.Identity, audit identity.Audit) (identity.Identity, error) { return s.create(ctx, value, audit, value.Kind.Agent()) } // create inserts an identity, assigning an agent to the request's org when // assign is set. Boot seeding does not assign: it runs before a fresh // install's org exists, and the org upgrade assigns what it seeded. func (s *Store) create(ctx context.Context, value identity.Identity, audit identity.Audit, assign bool) (identity.Identity, error) { if err := value.Validate(); err != nil { return identity.Identity{}, err } now := audit.At.UTC() if now.IsZero() { now = time.Now().UTC() } value.Version, value.CreatedAt, value.UpdatedAt = 1, now, now tx, err := s.pool.Begin(ctx) if err != nil { return identity.Identity{}, err } defer func() { _ = tx.Rollback(ctx) }() q := postgresdb.New(tx) if err := q.InsertIdentity(ctx, postgresdb.InsertIdentityParams{ ID: string(value.ID), Kind: string(value.Kind), DisplayName: value.DisplayName, Lifecycle: string(value.Lifecycle), Version: value.Version, CreatedAt: now, UpdatedAt: now, }); err != nil { return identity.Identity{}, err } if err := q.InsertIdentityAlias(ctx, postgresdb.InsertIdentityAliasParams{ Alias: value.DisplayName, IdentityID: string(value.ID), }); err != nil { return identity.Identity{}, err } if err := insertIdentityEvent(ctx, q, org.OrgFromContext(ctx), value.ID, identity.Event{ IdentityID: value.ID, Type: "create", To: value.Lifecycle, DisplayName: value.DisplayName, }, audit, now); err != nil { return identity.Identity{}, err } if assign { if err := assignNewAgent(ctx, q, value.ID, org.OrgFromContext(ctx)); err != nil { return identity.Identity{}, err } } if err := tx.Commit(ctx); err != nil { return identity.Identity{}, err } return value, nil } // assignNewAgent makes a new agent serve orgID with the developer role. func assignNewAgent(ctx context.Context, q *postgresdb.Queries, id identity.IdentityID, orgID org.OrgID) error { if err := q.UpsertAgentAssignment(ctx, postgresdb.UpsertAgentAssignmentParams{ IdentityID: string(id), OrgID: string(orgID), }); err != nil { return fmt.Errorf("assign agent to org %s: %w", orgID, err) } return q.EnsureMembership(ctx, postgresdb.EnsureMembershipParams{ IdentityID: string(id), OrgID: string(orgID), Role: string(org.RoleDeveloper), }) } // Apply mutates an identity under an optimistic version guard and records the // lifecycle event. func (s *Store) Apply(ctx context.Context, id identity.IdentityID, expectedVersion int64, command identity.Command, audit identity.Audit) (identity.Identity, error) { tx, err := s.pool.Begin(ctx) if err != nil { return identity.Identity{}, err } defer func() { _ = tx.Rollback(ctx) }() q := postgresdb.New(tx) current, err := q.GetVisibleIdentity(ctx, postgresdb.GetVisibleIdentityParams{ID: string(id), ScopeOrg: memberScope(ctx)}) if errors.Is(err, pgx.ErrNoRows) { return identity.Identity{}, identity.ErrNotFound } if err != nil { return identity.Identity{}, err } cur := identityFromRow(current) if cur.Version != expectedVersion { return identity.Identity{}, identity.ErrConflict } next, ev, err := identity.Apply(cur, command) if err != nil { return identity.Identity{}, err } now := audit.At.UTC() if now.IsZero() { now = time.Now().UTC() } next.UpdatedAt = now if err := guardLeavingActive(ctx, tx, id, cur.Lifecycle, next.Lifecycle); err != nil { return identity.Identity{}, err } n, err := q.UpdateIdentity(ctx, postgresdb.UpdateIdentityParams{ ID: string(id), DisplayName: next.DisplayName, Lifecycle: string(next.Lifecycle), Version: next.Version, UpdatedAt: now, Version_2: expectedVersion, }) if err != nil { return identity.Identity{}, err } if n != 1 { return identity.Identity{}, identity.ErrConflict } if command.Type == identity.CommandRename { if err := q.InsertIdentityAliasIgnoreConflict(ctx, postgresdb.InsertIdentityAliasIgnoreConflictParams{ Alias: next.DisplayName, IdentityID: string(id), }); err != nil { return identity.Identity{}, err } } if err := insertIdentityEvent(ctx, q, "", id, ev, audit, now); err != nil { return identity.Identity{}, err } if err := tx.Commit(ctx); err != nil { return identity.Identity{}, err } return next, nil } // guardLeavingActive refuses suspending or retiring an org's last active // owner, and signs out an identity that may no longer act. func guardLeavingActive(ctx context.Context, tx pgx.Tx, id identity.IdentityID, from, to identity.Lifecycle) error { if to == identity.LifecycleActive { return nil } if from == identity.LifecycleActive { if err := keepActiveOwner(ctx, tx, string(id), ""); err != nil { return err } } _, err := tx.Exec(ctx, `DELETE FROM account_sessions WHERE identity_id=$1`, string(id)) return err } // ResolveSubject returns the identity bound to a provider subject. func (s *Store) ResolveSubject(ctx context.Context, subject identity.Subject) (identity.Identity, error) { i, err := s.queries().ResolveIdentitySubject(ctx, postgresdb.ResolveIdentitySubjectParams{ Issuer: subject.Issuer, Subject: subject.Subject, }) if errors.Is(err, pgx.ErrNoRows) { return identity.Identity{}, identity.ErrNotFound } if err != nil { return identity.Identity{}, err } return identityFromRow(i), nil } // ClaimSubject moves a placeholder binding (a person added by email) onto // the subject the provider asserts. The placeholder is gone afterwards, so a // second account showing the same address finds nothing to claim. func (s *Store) ClaimSubject(ctx context.Context, placeholder, subject identity.Subject) (identity.Identity, error) { if err := subject.Validate(); err != nil { return identity.Identity{}, err } now := time.Now().UTC() var claimed identity.Identity err := pgx.BeginFunc(ctx, s.pool, func(tx pgx.Tx) error { q := postgresdb.New(tx) id, err := q.ClaimIdentitySubject(ctx, postgresdb.ClaimIdentitySubjectParams{ Issuer: placeholder.Issuer, Placeholder: placeholder.Subject, Subject: subject.Subject, BoundAt: now, }) if errors.Is(err, pgx.ErrNoRows) { return identity.ErrNotFound } if err != nil { return err } row, err := q.GetIdentity(ctx, id) if err != nil { return err } claimed = identityFromRow(row) return insertIdentityEvent(ctx, q, "", claimed.ID, identity.Event{ IdentityID: claimed.ID, Type: "claim_subject", From: claimed.Lifecycle, To: claimed.Lifecycle, DisplayName: subject.Subject, }, identity.Audit{ActorID: claimed.ID, Source: "sign-in", RequestID: placeholder.Subject}, now) }) return claimed, err } // BindSubject binds an identity to the provider subject that asserts it, // moving any prior binding for that subject. func (s *Store) BindSubject(ctx context.Context, id identity.IdentityID, subject identity.Subject, audit identity.Audit) error { if err := subject.Validate(); err != nil { return err } if audit.ActorID == "" || audit.Source == "" || audit.RequestID == "" { return fmt.Errorf("%w: audit actor, source, and request ID are required", identity.ErrInvalid) } now := audit.At.UTC() if now.IsZero() { now = time.Now().UTC() } tx, err := s.pool.Begin(ctx) if err != nil { return err } defer func() { _ = tx.Rollback(ctx) }() q := postgresdb.New(tx) current, err := q.GetVisibleIdentity(ctx, postgresdb.GetVisibleIdentityParams{ID: string(id), ScopeOrg: memberScope(ctx)}) if errors.Is(err, pgx.ErrNoRows) { return identity.ErrNotFound } if err != nil { return err } cur := identityFromRow(current) if err := q.UpsertIdentitySubject(ctx, postgresdb.UpsertIdentitySubjectParams{ Issuer: subject.Issuer, Subject: subject.Subject, IdentityID: string(id), BoundAt: now, }); err != nil { return err } if err := insertIdentityEvent(ctx, q, "", id, identity.Event{ IdentityID: id, Type: "bind_subject", From: cur.Lifecycle, To: cur.Lifecycle, DisplayName: subject.Subject, }, audit, now); err != nil { return err } return tx.Commit(ctx) } var _ identity.PersonalTokenStore = (*Store)(nil) // SubjectsOf lists an identity's bindings under one issuer, newest first. func (s *Store) SubjectsOf(ctx context.Context, id identity.IdentityID, issuer string) ([]identity.PersonalToken, error) { rows, err := postgresdb.New(s.pool).ListIdentitySubjects(ctx, postgresdb.ListIdentitySubjectsParams{IdentityID: string(id), Issuer: issuer}) if err != nil { return nil, err } out := make([]identity.PersonalToken, 0, len(rows)) for _, row := range rows { out = append(out, identity.PersonalToken{ID: row.Subject, CreatedAt: row.BoundAt}) } return out, nil } // UnbindSubject removes one of an identity's bindings; a binding the // identity does not hold is ErrNotFound, so no caller can remove another's. func (s *Store) UnbindSubject(ctx context.Context, id identity.IdentityID, subject identity.Subject, audit identity.Audit) error { if audit.ActorID == "" || audit.Source == "" || audit.RequestID == "" { return fmt.Errorf("%w: audit actor, source, and request ID are required", identity.ErrInvalid) } now := audit.At.UTC() if now.IsZero() { now = time.Now().UTC() } return pgx.BeginFunc(ctx, s.pool, func(tx pgx.Tx) error { q := postgresdb.New(tx) current, err := q.GetVisibleIdentity(ctx, postgresdb.GetVisibleIdentityParams{ID: string(id), ScopeOrg: memberScope(ctx)}) if errors.Is(err, pgx.ErrNoRows) { return identity.ErrNotFound } if err != nil { return err } deleted, err := q.DeleteIdentitySubject(ctx, postgresdb.DeleteIdentitySubjectParams{ IdentityID: string(id), Issuer: subject.Issuer, Subject: subject.Subject, }) if err != nil { return err } if deleted == 0 { return identity.ErrNotFound } cur := identityFromRow(current) return insertIdentityEvent(ctx, q, "", id, identity.Event{ IdentityID: id, Type: "unbind_subject", From: cur.Lifecycle, To: cur.Lifecycle, DisplayName: subject.Subject, }, audit, now) }) } // BootstrapIdentities seeds the system identity and the legacy names, and // moves tasks carrying a legacy name to its stable id. Invalid names are // errors. func (s *Store) BootstrapIdentities(ctx context.Context, legacyNames []string) error { values := make([]identity.Identity, 0, len(legacyNames)+1) values = append(values, identity.System()) for _, name := range legacyNames { value, err := identity.FromLegacyName(name) if err != nil { return fmt.Errorf("bootstrap identity %q: %w", name, err) } values = append(values, value) } for _, value := range values { _, err := s.create(ctx, value, identity.Audit{ ActorID: identity.SystemID, Source: "legacy-config", RequestID: "identity-import:" + string(value.ID), }, false) if err != nil && !isUniqueViolation(err) { return fmt.Errorf("bootstrap identity %q: %w", value.DisplayName, err) } if err := s.queries().InsertIdentityAliasIgnoreConflict(ctx, postgresdb.InsertIdentityAliasIgnoreConflictParams{ Alias: value.DisplayName, IdentityID: string(value.ID), }); err != nil { return err } if value.Kind != identity.KindSystem { if err := s.queries().UpdateTaskIdentity(ctx, postgresdb.UpdateTaskIdentityParams{ Identity: string(value.ID), Identity_2: value.DisplayName, }); err != nil { return err } } } return nil }