package postgres import ( "context" "log" "time" "github.com/jackc/pgx/v5" "github.com/jackc/pgx/v5/pgxpool" "high-loud-apps-labs/internal/domain" ) type AttachmentRepo struct { pool *pgxpool.Pool } func NewAttachmentRepo(pool *pgxpool.Pool) *AttachmentRepo { return &AttachmentRepo{pool: pool} } func (r *AttachmentRepo) Create(ctx context.Context, a *domain.Attachment) error { const q = ` INSERT INTO attachments (id, chat_id, owner_id, filename, content_type, size_bytes, sha256, object_key, status, error_code, created_at, updated_at) VALUES ($1::uuid, $2::uuid, $3::uuid, $4, $5, $6, $7, $8, $9, NULL, $10, $10)` _, err := r.pool.Exec(ctx, q, a.ID, a.ChatID, a.OwnerID, a.Filename, a.ContentType, a.SizeBytes, a.SHA256, a.ObjectKey, string(a.Status), a.CreatedAt, ) if err != nil { if uniqueViolation(err) { return &domain.AlreadyExistsError{ Entity: "attachment", Field: "object_key", Value: a.ObjectKey, } } if foreignKeyViolation(err) { return &domain.NotFoundError{Entity: "chat", ID: a.ChatID} } if checkViolation(err) { return &domain.ValidationError{ Field: "attachment", Message: "нарушено ограничение целостности", } } return mapError(err) } return nil } func (r *AttachmentRepo) CreateInTx(ctx context.Context, tx domain.Tx, a *domain.Attachment) error { const q = ` INSERT INTO attachments (id, chat_id, owner_id, filename, content_type, size_bytes, sha256, object_key, status, error_code, attempts, pipeline_version, staging_key, created_at, updated_at) VALUES ($1::uuid, $2::uuid, $3::uuid, $4, $5, $6, $7, $8, $9, NULL, 0, $10, $11, $12, $12) ` return tx.Exec(ctx, q, a.ID, a.ChatID, a.OwnerID, a.Filename, a.ContentType, a.SizeBytes, a.SHA256, a.ObjectKey, string(a.Status), a.PipelineVersion, a.StagingKey, a.CreatedAt, ) } func (r *AttachmentRepo) GetByID(ctx context.Context, id string) (*domain.Attachment, error) { const q = ` SELECT id, chat_id, owner_id, filename, content_type, size_bytes, sha256, object_key, status, error_code, created_at, updated_at, attempts, next_attempt_at, locked_until, pipeline_version, staging_key FROM attachments WHERE id = $1::uuid ` a := &domain.Attachment{} var status string err := r.pool.QueryRow(ctx, q, id). Scan(&a.ID, &a.ChatID, &a.OwnerID, &a.Filename, &a.ContentType, &a.SizeBytes, &a.SHA256, &a.ObjectKey, &status, &a.ErrorCode, &a.CreatedAt, &a.UpdatedAt, &a.Attempts, &a.NextAttemptAt, &a.LockedUntil, &a.PipelineVersion, &a.StagingKey) if err != nil { return nil, notFound(err, "attachment", id) } a.Status = domain.AttachmentStatus(status) rows, err := r.pool.Query(ctx, ` SELECT name, object_key, content_type, size_bytes, width, height, sha256, created_at FROM attachment_variants WHERE attachment_id = $1::uuid ORDER BY name `, id) if err != nil { log.Printf("GetByID: ошибка запроса variants: %v", err) } else { defer rows.Close() for rows.Next() { var v domain.AttachmentVariant v.AttachmentID = id if err := rows.Scan(&v.Name, &v.ObjectKey, &v.ContentType, &v.SizeBytes, &v.Width, &v.Height, &v.SHA256, &v.CreatedAt); err != nil { log.Printf("GetByID: ошибка Scan variant: %v", err) } else { a.Variants = append(a.Variants, v) } } } return a, nil } func (r *AttachmentRepo) MarkReady(ctx context.Context, id string) error { const q = ` UPDATE attachments SET status = 'ready', updated_at = now() WHERE id = $1::uuid AND status = 'pending' ` tag, err := r.pool.Exec(ctx, q, id) if err != nil { return mapError(err) } if tag.RowsAffected() > 0 { return nil } var status string err = r.pool.QueryRow(ctx, `SELECT status FROM attachments WHERE id = $1::uuid`, id). Scan(&status) if err != nil { return notFound(err, "attachment", id) } switch domain.AttachmentStatus(status) { case domain.AttachmentStatusReady: return nil case domain.AttachmentStatusFailed: return &domain.ConflictError{Reason: "нельзя перевести failed-вложение в ready"} default: return &domain.ConflictError{Reason: "некорректное состояние вложения"} } } func (r *AttachmentRepo) MarkFailed(ctx context.Context, id, errorCode string) error { if errorCode == "" { return &domain.ValidationError{Field: "error_code", Message: "не может быть пустым"} } const q = ` UPDATE attachments SET status = 'failed', error_code = $2, updated_at = now() WHERE id = $1::uuid AND status = 'pending' ` tag, err := r.pool.Exec(ctx, q, id, errorCode) if err != nil { return mapError(err) } if tag.RowsAffected() > 0 { return nil } var status string err = r.pool.QueryRow(ctx, `SELECT status FROM attachments WHERE id = $1::uuid`, id). Scan(&status) if err != nil { return notFound(err, "attachment", id) } switch domain.AttachmentStatus(status) { case domain.AttachmentStatusFailed, domain.AttachmentStatusReady: return nil default: return &domain.ConflictError{Reason: "некорректное состояние вложения"} } } func (r *AttachmentRepo) ExistingKeys(ctx context.Context, keys []string) ([]string, error) { if len(keys) == 0 { return []string{}, nil } const q = `SELECT object_key FROM attachments WHERE object_key = ANY($1::text[])` rows, err := r.pool.Query(ctx, q, keys) if err != nil { return nil, mapError(err) } defer rows.Close() out := make([]string, 0, len(keys)) for rows.Next() { var k string if err := rows.Scan(&k); err != nil { return nil, mapError(err) } out = append(out, k) } return out, mapError(rows.Err()) } func (r *AttachmentRepo) ClaimForProcessing(ctx context.Context, id string, version int, lease time.Duration) (*domain.Attachment, error) { const q = ` UPDATE attachments SET status = 'processing', locked_until = now() + $2, updated_at = now(), attempts = attempts + 1 WHERE id = $1::uuid AND status = 'queued' AND pipeline_version = $3 RETURNING id, chat_id, staging_key, pipeline_version, object_key, content_type, attempts ` var a domain.Attachment err := r.pool.QueryRow(ctx, q, id, lease, version).Scan(&a.ID, &a.ChatID, &a.StagingKey, &a.PipelineVersion, &a.ObjectKey, &a.ContentType, &a.Attempts) if err != nil { if err == pgx.ErrNoRows { return nil, nil } return nil, mapError(err) } return &a, nil } func (r *AttachmentRepo) CompleteJob(ctx context.Context, id string, pipelineVersion int, variants []domain.AttachmentVariant) (bool, error) { tx, err := r.pool.Begin(ctx) if err != nil { return false, mapError(err) } defer func() { _ = tx.Rollback(ctx) }() const q = ` UPDATE attachments SET status = 'ready', locked_until = NULL, updated_at = now() WHERE id = $1::uuid AND pipeline_version = $2 AND status = 'processing' ` tag, err := tx.Exec(ctx, q, id, pipelineVersion) if err != nil { return false, mapError(err) } if tag.RowsAffected() == 0 { return false, nil } variantRepo := NewAttachmentVariantRepo(r.pool) for _, v := range variants { if err := variantRepo.Upsert(ctx, &pgxTx{tx: tx}, &v); err != nil { log.Printf("CompleteJob: ошибка Upsert %s: %v", v.Name, err) return false, err } else { log.Printf("CompleteJob: успешно добавлен вариант %s", v.Name) } } return true, mapError(tx.Commit(ctx)) } func (r *AttachmentRepo) FailJob(ctx context.Context, id string, errorCode string) error { const q = ` UPDATE attachments SET status = 'failed', error_code = $2, locked_until = NULL, updated_at = now() WHERE id = $1::uuid AND status = 'processing' ` _, err := r.pool.Exec(ctx, q, id, errorCode) return mapError(err) } func (r *AttachmentRepo) ScheduleRetry(ctx context.Context, id string, nextAttemptAt time.Time, errorCode string) error { const q = ` UPDATE attachments SET status = 'queued', error_code = NULL, next_attempt_at = $2, locked_until = NULL, updated_at = now() WHERE id = $1::uuid AND status = 'processing' ` _, err := r.pool.Exec(ctx, q, id, nextAttemptAt) return mapError(err) } func (r *AttachmentRepo) ResetForReplay(ctx context.Context, tx domain.Tx, id string) error { const q = ` UPDATE attachments SET status = 'queued', attempts = 0, error_code = NULL, locked_until = NULL, next_attempt_at = NULL, updated_at = now() WHERE id = $1::uuid AND status = 'failed' ` return tx.Exec(ctx, q, id) } // для сверщика. func (r *AttachmentRepo) ListExpiredLeases(ctx context.Context, limit int) ([]domain.Attachment, error) { const q = ` SELECT id, chat_id, owner_id, filename, content_type, size_bytes, sha256, object_key, status, error_code, created_at, updated_at, attempts, next_attempt_at, locked_until, pipeline_version, staging_key FROM attachments WHERE status = 'processing' AND locked_until < now() ORDER BY locked_until LIMIT $1 ` rows, err := r.pool.Query(ctx, q, limit) if err != nil { return nil, mapError(err) } defer rows.Close() var out []domain.Attachment for rows.Next() { var a domain.Attachment var status string err := rows.Scan(&a.ID, &a.ChatID, &a.OwnerID, &a.Filename, &a.ContentType, &a.SizeBytes, &a.SHA256, &a.ObjectKey, &status, &a.ErrorCode, &a.CreatedAt, &a.UpdatedAt, &a.Attempts, &a.NextAttemptAt, &a.LockedUntil, &a.PipelineVersion, &a.StagingKey) if err != nil { return nil, mapError(err) } a.Status = domain.AttachmentStatus(status) out = append(out, a) } return out, mapError(rows.Err()) } func (r *AttachmentRepo) ResetLease(ctx context.Context, id string) error { const q = ` UPDATE attachments SET status = 'queued', locked_until = NULL, updated_at = now() WHERE id = $1::uuid AND status = 'processing' AND locked_until < now() ` _, err := r.pool.Exec(ctx, q, id) return mapError(err) } func (r *AttachmentRepo) ListStagingToCleanup(ctx context.Context, limit int) ([]domain.Attachment, error) { const q = ` SELECT id, staging_key FROM attachments WHERE status = 'ready' AND staging_key IS NOT NULL LIMIT $1 ` rows, err := r.pool.Query(ctx, q, limit) if err != nil { return nil, mapError(err) } defer rows.Close() var out []domain.Attachment for rows.Next() { var a domain.Attachment if err := rows.Scan(&a.ID, &a.StagingKey); err != nil { return nil, mapError(err) } out = append(out, a) } return out, mapError(rows.Err()) } func (r *AttachmentRepo) ClearStagingKey(ctx context.Context, id string) error { const q = `UPDATE attachments SET staging_key = NULL WHERE id = $1::uuid` _, err := r.pool.Exec(ctx, q, id) return mapError(err) } var _ domain.AttachmentRepository = (*AttachmentRepo)(nil)