feat(api): CRUD accounts/templates/domains + import зон (полный цикл), secret не в ответах

Task 9 Фазы 1B: узкий интерфейс TenantStore (внутри store.Account/Template/Domain,
без db.* в api) реализован тонкими обёртками в internal/store/tenant.go; API.Store/
Cipher/Reg добавлены к существующему Svc. Роуты POST/GET/DELETE для accounts/
templates/domains + POST /accounts/{aid}/import (ListZones -> CreateDomain на зону).
accountResponse не содержит секрет ни в каком виде.

internal/store/tenant.go

@@ -0,0 +1,153 @@
+package store
+
+import (
+	"context"
+
+	"github.com/google/uuid"
+
+	"github.com/vasyakrg/dns-autoresolver/internal/store/db"
+	"github.com/vasyakrg/dns-autoresolver/internal/store/dto"
+)
+
+// Account/Template/Domain are provider-neutral domain structs returned by the
+// thin wrappers below, so callers (internal/api) never need to import
+// internal/store/db directly.
+
+type Account struct {
+	ID        uuid.UUID
+	ProjectID uuid.UUID
+	Provider  string
+	SecretEnc string
+	Comment   string
+}
+
+func accountFromDB(a db.ProviderAccount) Account {
+	return Account{ID: a.ID, ProjectID: a.ProjectID, Provider: a.Provider, SecretEnc: a.SecretEnc, Comment: a.Comment}
+}
+
+func (s *Store) CreateAccount(ctx context.Context, projectID uuid.UUID, provider, secretEnc, comment string) (Account, error) {
+	a, err := s.q.CreateAccount(ctx, db.CreateAccountParams{
+		ID: uuid.New(), ProjectID: projectID, Provider: provider, SecretEnc: secretEnc, Comment: comment,
+	})
+	if err != nil {
+		return Account{}, err
+	}
+	return accountFromDB(a), nil
+}
+
+func (s *Store) ListAccounts(ctx context.Context, projectID uuid.UUID) ([]Account, error) {
+	rows, err := s.q.ListAccounts(ctx, projectID)
+	if err != nil {
+		return nil, err
+	}
+	out := make([]Account, 0, len(rows))
+	for _, r := range rows {
+		out = append(out, accountFromDB(r))
+	}
+	return out, nil
+}
+
+func (s *Store) GetAccount(ctx context.Context, id, projectID uuid.UUID) (Account, error) {
+	a, err := s.q.GetAccount(ctx, db.GetAccountParams{ID: id, ProjectID: projectID})
+	if err != nil {
+		return Account{}, err
+	}
+	return accountFromDB(a), nil
+}
+
+func (s *Store) DeleteAccount(ctx context.Context, id, projectID uuid.UUID) error {
+	return s.q.DeleteAccount(ctx, db.DeleteAccountParams{ID: id, ProjectID: projectID})
+}
+
+type Template struct {
+	ID        uuid.UUID
+	ProjectID uuid.UUID
+	Name      string
+	Doc       dto.TemplateDoc
+	Version   int32
+}
+
+func templateFromDB(t db.Template) Template {
+	var doc dto.TemplateDoc
+	if t.Doc != nil {
+		doc = *t.Doc
+	}
+	return Template{ID: t.ID, ProjectID: t.ProjectID, Name: t.Name, Doc: doc, Version: t.Version}
+}
+
+func (s *Store) CreateTemplate(ctx context.Context, projectID uuid.UUID, name string, doc dto.TemplateDoc) (Template, error) {
+	d := doc
+	t, err := s.q.CreateTemplate(ctx, db.CreateTemplateParams{ID: uuid.New(), ProjectID: projectID, Name: name, Doc: &d})
+	if err != nil {
+		return Template{}, err
+	}
+	return templateFromDB(t), nil
+}
+
+func (s *Store) ListTemplates(ctx context.Context, projectID uuid.UUID) ([]Template, error) {
+	rows, err := s.q.ListTemplates(ctx, projectID)
+	if err != nil {
+		return nil, err
+	}
+	out := make([]Template, 0, len(rows))
+	for _, r := range rows {
+		out = append(out, templateFromDB(r))
+	}
+	return out, nil
+}
+
+func (s *Store) UpdateTemplate(ctx context.Context, id, projectID uuid.UUID, name string, doc dto.TemplateDoc) (Template, error) {
+	d := doc
+	t, err := s.q.UpdateTemplate(ctx, db.UpdateTemplateParams{ID: id, ProjectID: projectID, Name: name, Doc: &d})
+	if err != nil {
+		return Template{}, err
+	}
+	return templateFromDB(t), nil
+}
+
+func (s *Store) DeleteTemplate(ctx context.Context, id, projectID uuid.UUID) error {
+	return s.q.DeleteTemplate(ctx, db.DeleteTemplateParams{ID: id, ProjectID: projectID})
+}
+
+type Domain struct {
+	ID                uuid.UUID
+	ProjectID         uuid.UUID
+	ProviderAccountID uuid.UUID
+	ZoneName          string
+	ZoneID            string
+	TemplateID        *uuid.UUID
+}
+
+func domainFromDB(d db.Domain) Domain {
+	return Domain{
+		ID: d.ID, ProjectID: d.ProjectID, ProviderAccountID: d.ProviderAccountID,
+		ZoneName: d.ZoneName, ZoneID: d.ZoneID, TemplateID: d.TemplateID,
+	}
+}
+
+func (s *Store) CreateDomain(ctx context.Context, projectID, accountID uuid.UUID, zoneName, zoneID string, templateID *uuid.UUID) (Domain, error) {
+	d, err := s.q.CreateDomain(ctx, db.CreateDomainParams{
+		ID: uuid.New(), ProjectID: projectID, ProviderAccountID: accountID,
+		ZoneName: zoneName, ZoneID: zoneID, TemplateID: templateID,
+	})
+	if err != nil {
+		return Domain{}, err
+	}
+	return domainFromDB(d), nil
+}
+
+func (s *Store) ListDomains(ctx context.Context, projectID uuid.UUID) ([]Domain, error) {
+	rows, err := s.q.ListDomains(ctx, projectID)
+	if err != nil {
+		return nil, err
+	}
+	out := make([]Domain, 0, len(rows))
+	for _, r := range rows {
+		out = append(out, domainFromDB(r))
+	}
+	return out, nil
+}
+
+func (s *Store) DeleteDomain(ctx context.Context, id, projectID uuid.UUID) error {
+	return s.q.DeleteDomain(ctx, db.DeleteDomainParams{ID: id, ProjectID: projectID})
+}