Janady13/missionmatch / internal/platform/database/dbgen/teaching.sql.go

1// Code generated by sqlc. DO NOT EDIT. 2// versions: 3// sqlc v1.31.1 4// source: teaching.sql 5 6package dbgen 7 8import ( 9 "context" 10 "time" 11 12 "github.com/google/uuid" 13 "github.com/jackc/pgx/v5/pgtype" 14 "github.com/shopspring/decimal" 15) 16 17const approveProposalTx = `-- name: ApproveProposalTx :one 18UPDATE curation_proposals 19 SET status = 'approved', approver = $2, approved_at = now() 20 WHERE id = $1 21 AND status = 'pending' 22RETURNING id, kind, from_skill_id, to_skill_id, relation, proposed_strength, 23 evidence_observations, evidence_successes, model_version, status, approver, approved_at, created_at 24` 25 26type ApproveProposalTxParams struct { 27 ID uuid.UUID `json:"id"` 28 Approver *uuid.UUID `json:"approver"` 29} 30 31// The first of two human steps. Set status to approved and record the approver and approved_at, but ONLY when 32// the proposal is still pending, so a double submit or a concurrent approval cannot move an already decided 33// proposal. Returns the row only on a real transition; zero rows means it was not pending. Migrator pool. 34func (q *Queries) ApproveProposalTx(ctx context.Context, arg ApproveProposalTxParams) (CurationProposal, error) { 35 row := q.db.QueryRow(ctx, approveProposalTx, arg.ID, arg.Approver) 36 var i CurationProposal 37 err := row.Scan( 38 &i.ID, 39 &i.Kind, 40 &i.FromSkillID, 41 &i.ToSkillID, 42 &i.Relation, 43 &i.ProposedStrength, 44 &i.EvidenceObservations, 45 &i.EvidenceSuccesses, 46 &i.ModelVersion, 47 &i.Status, 48 &i.Approver, 49 &i.ApprovedAt, 50 &i.CreatedAt, 51 ) 52 return i, err 53} 54 55const getActiveProposalForPair = `-- name: GetActiveProposalForPair :one 56SELECT id, kind, status, from_skill_id, to_skill_id, relation, proposed_strength 57 FROM curation_proposals 58 WHERE from_skill_id = $1 59 AND to_skill_id = $2 60 AND relation = $3 61 AND status IN ('pending', 'approved') 62 LIMIT 1 63` 64 65type GetActiveProposalForPairParams struct { 66 FromSkillID *uuid.UUID `json:"from_skill_id"` 67 ToSkillID *uuid.UUID `json:"to_skill_id"` 68 Relation *string `json:"relation"` 69} 70 71type GetActiveProposalForPairRow struct { 72 ID uuid.UUID `json:"id"` 73 Kind string `json:"kind"` 74 Status string `json:"status"` 75 FromSkillID *uuid.UUID `json:"from_skill_id"` 76 ToSkillID *uuid.UUID `json:"to_skill_id"` 77 Relation *string `json:"relation"` 78 ProposedStrength *decimal.Decimal `json:"proposed_strength"` 79} 80 81// Idempotency guard for the proposal generator: returns the existing proposal for a (from_skill_id, 82// to_skill_id, relation) triple that is still pending or already approved, so the generator never creates a 83// duplicate suggestion for a pair a human is already deciding or has already decided. A rejected proposal is 84// intentionally NOT matched here, so a human who rejected a pair can see it proposed again if the evidence 85// recurs (the human stays in control either way). Migrator pool, the global table. 86func (q *Queries) GetActiveProposalForPair(ctx context.Context, arg GetActiveProposalForPairParams) (GetActiveProposalForPairRow, error) { 87 row := q.db.QueryRow(ctx, getActiveProposalForPair, arg.FromSkillID, arg.ToSkillID, arg.Relation) 88 var i GetActiveProposalForPairRow 89 err := row.Scan( 90 &i.ID, 91 &i.Kind, 92 &i.Status, 93 &i.FromSkillID, 94 &i.ToSkillID, 95 &i.Relation, 96 &i.ProposedStrength, 97 ) 98 return i, err 99} 100 101const getLatestDpBudgetLedger = `-- name: GetLatestDpBudgetLedger :one 102SELECT id, model_version, tenant_id, rdp_orders, accumulated_rdp, epsilon_at_delta, delta, 103 contributing_tenant_count, released_at 104 FROM dp_budget_ledger 105 WHERE model_version = $1 106 AND coalesce(tenant_id, '00000000-0000-0000-0000-000000000000'::uuid) 107 = coalesce($2::uuid, '00000000-0000-0000-0000-000000000000'::uuid) 108 ORDER BY released_at DESC, id DESC 109 LIMIT 1 110` 111 112type GetLatestDpBudgetLedgerParams struct { 113 ModelVersion string `json:"model_version"` 114 TenantID *uuid.UUID `json:"tenant_id"` 115} 116 117// The hard spend gate read. It returns the most recent ledger row for one (model_version, tenant_id) budget 118// key, which carries the running accumulated RDP after every release composed so far. The gate adds the 119// candidate release's per order RDP to this accumulation, reconverts to epsilon at the configured delta, and 120// refuses the release (writing nothing) if it would exceed the budget. coalesce maps a NULL tenant_id (the 121// cross tenant cohort) onto the fixed nil uuid so the cross tenant releases share one budget key space, the 122// same convention the aggregates table uses. Ordered released_at then id descending so the newest composed 123// accumulation is row one; zero rows means this is the first release on a fresh budget. dp_budget_ledger is a 124// global migrator owned table the app role can only SELECT, so this read runs through the migrator pool. 125func (q *Queries) GetLatestDpBudgetLedger(ctx context.Context, arg GetLatestDpBudgetLedgerParams) (DpBudgetLedger, error) { 126 row := q.db.QueryRow(ctx, getLatestDpBudgetLedger, arg.ModelVersion, arg.TenantID) 127 var i DpBudgetLedger 128 err := row.Scan( 129 &i.ID, 130 &i.ModelVersion, 131 &i.TenantID, 132 &i.RdpOrders, 133 &i.AccumulatedRdp, 134 &i.EpsilonAtDelta, 135 &i.Delta, 136 &i.ContributingTenantCount, 137 &i.ReleasedAt, 138 ) 139 return i, err 140} 141 142const getProposal = `-- name: GetProposal :one 143SELECT id, kind, from_skill_id, to_skill_id, relation, proposed_strength, 144 evidence_observations, evidence_successes, model_version, status, approver, approved_at, created_at 145 FROM curation_proposals 146 WHERE id = $1 147` 148 149// Read one proposal by id for the approve and verify handlers. Migrator pool, the global table. 150func (q *Queries) GetProposal(ctx context.Context, id uuid.UUID) (CurationProposal, error) { 151 row := q.db.QueryRow(ctx, getProposal, id) 152 var i CurationProposal 153 err := row.Scan( 154 &i.ID, 155 &i.Kind, 156 &i.FromSkillID, 157 &i.ToSkillID, 158 &i.Relation, 159 &i.ProposedStrength, 160 &i.EvidenceObservations, 161 &i.EvidenceSuccesses, 162 &i.ModelVersion, 163 &i.Status, 164 &i.Approver, 165 &i.ApprovedAt, 166 &i.CreatedAt, 167 ) 168 return i, err 169} 170 171const insertCurationProposal = `-- name: InsertCurationProposal :one 172INSERT INTO curation_proposals ( 173 kind, from_skill_id, to_skill_id, relation, proposed_strength, 174 evidence_observations, evidence_successes, model_version 175) VALUES ($1, $2, $3, $4, $5, $6, $7, $8) 176RETURNING id, kind, from_skill_id, to_skill_id, relation, proposed_strength, 177 evidence_observations, evidence_successes, model_version, status, approver, approved_at, created_at 178` 179 180type InsertCurationProposalParams struct { 181 Kind string `json:"kind"` 182 FromSkillID *uuid.UUID `json:"from_skill_id"` 183 ToSkillID *uuid.UUID `json:"to_skill_id"` 184 Relation *string `json:"relation"` 185 ProposedStrength *decimal.Decimal `json:"proposed_strength"` 186 EvidenceObservations int32 `json:"evidence_observations"` 187 EvidenceSuccesses int32 `json:"evidence_successes"` 188 ModelVersion string `json:"model_version"` 189} 190 191// Create a pending curation proposal. Never auto applied and never auto rejected: status defaults to pending, 192// approver and approved_at stay NULL until a human acts. Migrator pool only, because curation_proposals is a 193// global migrator owned table the app role can only SELECT. 194func (q *Queries) InsertCurationProposal(ctx context.Context, arg InsertCurationProposalParams) (CurationProposal, error) { 195 row := q.db.QueryRow(ctx, insertCurationProposal, 196 arg.Kind, 197 arg.FromSkillID, 198 arg.ToSkillID, 199 arg.Relation, 200 arg.ProposedStrength, 201 arg.EvidenceObservations, 202 arg.EvidenceSuccesses, 203 arg.ModelVersion, 204 ) 205 var i CurationProposal 206 err := row.Scan( 207 &i.ID, 208 &i.Kind, 209 &i.FromSkillID, 210 &i.ToSkillID, 211 &i.Relation, 212 &i.ProposedStrength, 213 &i.EvidenceObservations, 214 &i.EvidenceSuccesses, 215 &i.ModelVersion, 216 &i.Status, 217 &i.Approver, 218 &i.ApprovedAt, 219 &i.CreatedAt, 220 ) 221 return i, err 222} 223 224const insertDpBudgetLedger = `-- name: InsertDpBudgetLedger :one 225INSERT INTO dp_budget_ledger ( 226 model_version, tenant_id, rdp_orders, accumulated_rdp, epsilon_at_delta, delta, 227 contributing_tenant_count 228) VALUES ($1, $2, $3, $4, $5, $6, $7) 229RETURNING id, model_version, tenant_id, rdp_orders, accumulated_rdp, epsilon_at_delta, delta, 230 contributing_tenant_count, released_at 231` 232 233type InsertDpBudgetLedgerParams struct { 234 ModelVersion string `json:"model_version"` 235 TenantID *uuid.UUID `json:"tenant_id"` 236 RdpOrders []byte `json:"rdp_orders"` 237 AccumulatedRdp decimal.Decimal `json:"accumulated_rdp"` 238 EpsilonAtDelta decimal.Decimal `json:"epsilon_at_delta"` 239 Delta decimal.Decimal `json:"delta"` 240 ContributingTenantCount int32 `json:"contributing_tenant_count"` 241} 242 243// Record one differential privacy release in the append only budget ledger. The gate inserts this ONLY after 244// it has confirmed the release stays within budget, so a persisted row is by construction an in budget, 245// already audited release. rdp_orders is the jsonb map of Renyi order to the per order accumulated RDP at 246// this release; accumulated_rdp is the running RDP over the worst case (max over the grid converted) used for 247// the human readable summary; epsilon_at_delta is the converted epsilon (the min over orders) at the target 248// delta; delta is that target; contributing_tenant_count is the number of live non test distinct 249// organizations in the cohort, sourced from the production flag, never a literal. The spent epsilon columns 250// are numeric so the audit record is bit stable while the grid math ran in float64. dp_budget_ledger is a 251// global migrator owned table the app role can only SELECT, so this write runs through the migrator pool. 252func (q *Queries) InsertDpBudgetLedger(ctx context.Context, arg InsertDpBudgetLedgerParams) (DpBudgetLedger, error) { 253 row := q.db.QueryRow(ctx, insertDpBudgetLedger, 254 arg.ModelVersion, 255 arg.TenantID, 256 arg.RdpOrders, 257 arg.AccumulatedRdp, 258 arg.EpsilonAtDelta, 259 arg.Delta, 260 arg.ContributingTenantCount, 261 ) 262 var i DpBudgetLedger 263 err := row.Scan( 264 &i.ID, 265 &i.ModelVersion, 266 &i.TenantID, 267 &i.RdpOrders, 268 &i.AccumulatedRdp, 269 &i.EpsilonAtDelta, 270 &i.Delta, 271 &i.ContributingTenantCount, 272 &i.ReleasedAt, 273 ) 274 return i, err 275} 276 277const listPendingProposals = `-- name: ListPendingProposals :many 278SELECT id, kind, from_skill_id, to_skill_id, relation, proposed_strength, 279 evidence_observations, evidence_successes, model_version, status, approver, approved_at, created_at 280 FROM curation_proposals 281 WHERE status = 'pending' 282 ORDER BY created_at, id 283` 284 285// The /compliance surface of proposals awaiting the first human step. Migrator pool, the global table, gated 286// behind the compliance or operator role at the handler. Ordered oldest first so the queue is a stable list. 287func (q *Queries) ListPendingProposals(ctx context.Context) ([]CurationProposal, error) { 288 rows, err := q.db.Query(ctx, listPendingProposals) 289 if err != nil { 290 return nil, err 291 } 292 defer rows.Close() 293 items := []CurationProposal{} 294 for rows.Next() { 295 var i CurationProposal 296 if err := rows.Scan( 297 &i.ID, 298 &i.Kind, 299 &i.FromSkillID, 300 &i.ToSkillID, 301 &i.Relation, 302 &i.ProposedStrength, 303 &i.EvidenceObservations, 304 &i.EvidenceSuccesses, 305 &i.ModelVersion, 306 &i.Status, 307 &i.Approver, 308 &i.ApprovedAt, 309 &i.CreatedAt, 310 ); err != nil { 311 return nil, err 312 } 313 items = append(items, i) 314 } 315 if err := rows.Err(); err != nil { 316 return nil, err 317 } 318 return items, nil 319} 320 321const listSlateDecisionEvidenceForOrg = `-- name: ListSlateDecisionEvidenceForOrg :many 322SELECT 323 sm.candidate_id, 324 sm.decision, 325 sm.clearance_score, 326 sm.experience_score, 327 sm.gap_summary, 328 s.requirement_id, 329 r.required_level, 330 ce.matched_skills 331FROM slate_members sm 332JOIN slates s 333 ON s.organization_id = sm.organization_id 334 AND s.id = sm.slate_id 335JOIN requirements r 336 ON r.organization_id = s.organization_id 337 AND r.id = s.requirement_id 338LEFT JOIN candidate_evaluations ce 339 ON ce.organization_id = sm.organization_id 340 AND ce.candidate_id = sm.candidate_id 341 AND ce.requirement_id = s.requirement_id 342ORDER BY sm.slate_id, sm.candidate_id 343` 344 345type ListSlateDecisionEvidenceForOrgRow struct { 346 CandidateID uuid.UUID `json:"candidate_id"` 347 Decision string `json:"decision"` 348 ClearanceScore decimal.Decimal `json:"clearance_score"` 349 ExperienceScore decimal.Decimal `json:"experience_score"` 350 GapSummary []byte `json:"gap_summary"` 351 RequirementID uuid.UUID `json:"requirement_id"` 352 RequiredLevel string `json:"required_level"` 353 MatchedSkills []byte `json:"matched_skills"` 354} 355 356// The WS8 in tenant teaching read. It returns ONLY the contents free craft evidence the producer folds 357// into scrub.TeachingSignal counts: the reviewer decision on each slate member, the stored sub scores that 358// reveal a clearance gap (clearance_score) or an experience shortfall (experience_score), the frozen gap 359// summary, and the matched skills evidence (per skill similarity and whether the match was exact or a 360// semantic substitution) from the candidate's persisted evaluation. It carries NO name, NO email, NO free 361// text resume, only the decision label, the scores, and the jsonb match evidence the engine itself froze. 362// 363// Both slate_members and candidate_evaluations are RLS scoped, and the producer runs this inside 364// RunInTenantTx on the app pool, so the join is scoped to the caller's org by Postgres Row Level Security 365// and can never read another tenant's decisions. candidate_evaluations is LEFT joined on the pair 366// (organization_id, candidate_id, requirement_id): a slate member that was never screened through 367// screenMATCH has no stored evaluation, so the matched skills evidence is then NULL and the producer folds 368// only what slate_members alone supports (the clearance and experience patterns), never fabricating a 369// skill substitution it cannot see. 370func (q *Queries) ListSlateDecisionEvidenceForOrg(ctx context.Context) ([]ListSlateDecisionEvidenceForOrgRow, error) { 371 rows, err := q.db.Query(ctx, listSlateDecisionEvidenceForOrg) 372 if err != nil { 373 return nil, err 374 } 375 defer rows.Close() 376 items := []ListSlateDecisionEvidenceForOrgRow{} 377 for rows.Next() { 378 var i ListSlateDecisionEvidenceForOrgRow 379 if err := rows.Scan( 380 &i.CandidateID, 381 &i.Decision, 382 &i.ClearanceScore, 383 &i.ExperienceScore, 384 &i.GapSummary, 385 &i.RequirementID, 386 &i.RequiredLevel, 387 &i.MatchedSkills, 388 ); err != nil { 389 return nil, err 390 } 391 items = append(items, i) 392 } 393 if err := rows.Err(); err != nil { 394 return nil, err 395 } 396 return items, nil 397} 398 399const listTeachingAggregatesForTenant = `-- name: ListTeachingAggregatesForTenant :many 400SELECT id, tenant_id, dp_applied, pattern, band, outcome, model_version, observations, successes, 401 window_start, window_end, created_at 402 FROM teaching_signal_aggregates 403 WHERE tenant_id = $1 404 AND dp_applied = false 405 AND model_version = $2 406` 407 408type ListTeachingAggregatesForTenantParams struct { 409 TenantID *uuid.UUID `json:"tenant_id"` 410 ModelVersion string `json:"model_version"` 411} 412 413// The cross cutting GOVERNANCE CONFIDENCE the proposal generator reads: this tenant's own folded craft counts 414// for the live in tenant rows (dp_applied false). The generator uses these to confirm a craft pattern is 415// reliably approved at a band before it ever proposes a curated edge, so the specific recurring pair (read 416// from the tenant's own evaluations) is only proposed when the contents free aggregate also supports it. 417// These rows carry NO PII and no candidate id, only the counts. Migrator pool, the global table; the tenant 418// is passed explicitly because this read is governance confidence, not the RLS scoped evaluation scan. 419func (q *Queries) ListTeachingAggregatesForTenant(ctx context.Context, arg ListTeachingAggregatesForTenantParams) ([]TeachingSignalAggregate, error) { 420 rows, err := q.db.Query(ctx, listTeachingAggregatesForTenant, arg.TenantID, arg.ModelVersion) 421 if err != nil { 422 return nil, err 423 } 424 defer rows.Close() 425 items := []TeachingSignalAggregate{} 426 for rows.Next() { 427 var i TeachingSignalAggregate 428 if err := rows.Scan( 429 &i.ID, 430 &i.TenantID, 431 &i.DpApplied, 432 &i.Pattern, 433 &i.Band, 434 &i.Outcome, 435 &i.ModelVersion, 436 &i.Observations, 437 &i.Successes, 438 &i.WindowStart, 439 &i.WindowEnd, 440 &i.CreatedAt, 441 ); err != nil { 442 return nil, err 443 } 444 items = append(items, i) 445 } 446 if err := rows.Err(); err != nil { 447 return nil, err 448 } 449 return items, nil 450} 451 452const resolveSkillIDByName = `-- name: ResolveSkillIDByName :one 453SELECT id FROM skills WHERE lower(name) = lower(trim($1)) 454` 455 456// Resolve a skill name to its global skills.id, lower cased and trimmed, so a matched_skills entry that 457// carries a candidate or required skill NAME but no id can still be turned into the id the proposal and the 458// staged edge need. The skills table is global reference data the app role may SELECT; the proposal generator 459// runs this through the same RLS scoped app tx that read the org's evaluations (the read is the only app 460// pool step, the proposal WRITE goes through the migrator pool). 461func (q *Queries) ResolveSkillIDByName(ctx context.Context, btrim string) (uuid.UUID, error) { 462 row := q.db.QueryRow(ctx, resolveSkillIDByName, btrim) 463 var id uuid.UUID 464 err := row.Scan(&id) 465 return id, err 466} 467 468const stageSubstitutesForEdge = `-- name: StageSubstitutesForEdge :one 469INSERT INTO skill_relationships (from_skill_id, to_skill_id, relation, strength, source, verified_at) 470VALUES ($1, $2, 'substitutes_for', $3, 'ws8_curation', NULL) 471ON CONFLICT (from_skill_id, to_skill_id, relation) DO UPDATE SET source = skill_relationships.source 472RETURNING id, from_skill_id, to_skill_id, relation, strength, verified_at 473` 474 475type StageSubstitutesForEdgeParams struct { 476 FromSkillID uuid.UUID `json:"from_skill_id"` 477 ToSkillID uuid.UUID `json:"to_skill_id"` 478 Strength decimal.Decimal `json:"strength"` 479} 480 481type StageSubstitutesForEdgeRow struct { 482 ID uuid.UUID `json:"id"` 483 FromSkillID uuid.UUID `json:"from_skill_id"` 484 ToSkillID uuid.UUID `json:"to_skill_id"` 485 Relation string `json:"relation"` 486 Strength decimal.Decimal `json:"strength"` 487 VerifiedAt *time.Time `json:"verified_at"` 488} 489 490// Insert the staged, INERT skill_relationships edge that an approval creates. verified_at is left NULL, so the 491// resolver (which loads only verified_at IS NOT NULL edges) ignores it and no score changes. A SECOND distinct 492// human action later sets verified_at to activate it. On a conflicting (from, to, relation) that already 493// exists, do nothing and return the existing row, so an approval is idempotent against a manually seeded edge. 494// Migrator pool only (skill_relationships is global, the app role has SELECT only). 495func (q *Queries) StageSubstitutesForEdge(ctx context.Context, arg StageSubstitutesForEdgeParams) (StageSubstitutesForEdgeRow, error) { 496 row := q.db.QueryRow(ctx, stageSubstitutesForEdge, arg.FromSkillID, arg.ToSkillID, arg.Strength) 497 var i StageSubstitutesForEdgeRow 498 err := row.Scan( 499 &i.ID, 500 &i.FromSkillID, 501 &i.ToSkillID, 502 &i.Relation, 503 &i.Strength, 504 &i.VerifiedAt, 505 ) 506 return i, err 507} 508 509const upsertTeachingSignalAggregate = `-- name: UpsertTeachingSignalAggregate :exec 510INSERT INTO teaching_signal_aggregates ( 511 tenant_id, dp_applied, pattern, band, outcome, model_version, 512 observations, successes, window_start, window_end 513) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10) 514ON CONFLICT ( 515 coalesce(tenant_id, '00000000-0000-0000-0000-000000000000'::uuid), 516 pattern, band, outcome, model_version, window_start 517) DO UPDATE SET 518 observations = EXCLUDED.observations, 519 successes = EXCLUDED.successes, 520 window_end = EXCLUDED.window_end, 521 dp_applied = EXCLUDED.dp_applied 522` 523 524type UpsertTeachingSignalAggregateParams struct { 525 TenantID *uuid.UUID `json:"tenant_id"` 526 DpApplied bool `json:"dp_applied"` 527 Pattern string `json:"pattern"` 528 Band string `json:"band"` 529 Outcome string `json:"outcome"` 530 ModelVersion string `json:"model_version"` 531 Observations int32 `json:"observations"` 532 Successes int32 `json:"successes"` 533 WindowStart pgtype.Date `json:"window_start"` 534 WindowEnd pgtype.Date `json:"window_end"` 535} 536 537// Persist one folded per tenant craft aggregate into the global teaching_signal_aggregates table. This is 538// a GLOBAL migrator owned table (app has SELECT only), so the producer runs this through the migrator pool 539// seam, never the app role. The unique key is (coalesce(tenant_id, the nil uuid), pattern, band, outcome, 540// model_version, window_start), so a rerun over the same window for the same tenant refreshes the counts in 541// place rather than inserting a duplicate, and a forked engine model version lands as a distinct row rather 542// than silently overwriting a prior version's aggregate. The live in tenant rows always carry tenant_id set 543// and dp_applied false; the flag on cross tenant path writes tenant_id NULL, dp_applied true rows later. 544func (q *Queries) UpsertTeachingSignalAggregate(ctx context.Context, arg UpsertTeachingSignalAggregateParams) error { 545 _, err := q.db.Exec(ctx, upsertTeachingSignalAggregate, 546 arg.TenantID, 547 arg.DpApplied, 548 arg.Pattern, 549 arg.Band, 550 arg.Outcome, 551 arg.ModelVersion, 552 arg.Observations, 553 arg.Successes, 554 arg.WindowStart, 555 arg.WindowEnd, 556 ) 557 return err 558} 559 560const verifyStagedEdge = `-- name: VerifyStagedEdge :one 561UPDATE skill_relationships 562 SET verified_at = now(), verifier = $2 563 WHERE id = $1 564 AND verified_at IS NULL 565RETURNING id, from_skill_id, to_skill_id, relation, strength, verified_at, verifier 566` 567 568type VerifyStagedEdgeParams struct { 569 ID uuid.UUID `json:"id"` 570 Verifier *uuid.UUID `json:"verifier"` 571} 572 573type VerifyStagedEdgeRow struct { 574 ID uuid.UUID `json:"id"` 575 FromSkillID uuid.UUID `json:"from_skill_id"` 576 ToSkillID uuid.UUID `json:"to_skill_id"` 577 Relation string `json:"relation"` 578 Strength decimal.Decimal `json:"strength"` 579 VerifiedAt *time.Time `json:"verified_at"` 580 Verifier *uuid.UUID `json:"verifier"` 581} 582 583// The second of two human steps. Activate a staged edge by setting verified_at and recording the verifier, 584// ONLY when it is still unverified, so a double submit cannot re activate or change the verifier of an already 585// live edge. The resolver reads verified_at IS NOT NULL edges, so this single write is what makes the edge 586// live across tenants. The engine math is byte identical: only the resolver reference set grew. Migrator pool. 587func (q *Queries) VerifyStagedEdge(ctx context.Context, arg VerifyStagedEdgeParams) (VerifyStagedEdgeRow, error) { 588 row := q.db.QueryRow(ctx, verifyStagedEdge, arg.ID, arg.Verifier) 589 var i VerifyStagedEdgeRow 590 err := row.Scan( 591 &i.ID, 592 &i.FromSkillID, 593 &i.ToSkillID, 594 &i.Relation, 595 &i.Strength, 596 &i.VerifiedAt, 597 &i.Verifier, 598 ) 599 return i, err 600} 601