From 10371e8fa6c1ae0d9d596c412daa6055f8acec0f Mon Sep 17 00:00:00 2001 From: dongwlin Date: Sat, 18 Jan 2025 23:17:45 +0800 Subject: [PATCH] refactor: introduce repo layer --- internal/handler/version.go | 18 +-- internal/logic/resource.go | 58 +------ internal/logic/storage.go | 35 ----- internal/logic/version.go | 293 ++++++++++++++++-------------------- internal/pkg/stg/storage.go | 4 + internal/repo/repo.go | 40 +++++ internal/repo/resource.go | 32 ++++ internal/repo/storage.go | 31 ++++ internal/repo/version.go | 62 ++++++++ internal/wire/wire.go | 16 +- internal/wire/wire_gen.go | 23 +-- 11 files changed, 329 insertions(+), 283 deletions(-) delete mode 100644 internal/logic/storage.go create mode 100644 internal/repo/repo.go create mode 100644 internal/repo/resource.go create mode 100644 internal/repo/storage.go create mode 100644 internal/repo/version.go diff --git a/internal/handler/version.go b/internal/handler/version.go index ee345f9..7136289 100644 --- a/internal/handler/version.go +++ b/internal/handler/version.go @@ -28,7 +28,6 @@ type VersionHandler struct { logger *zap.Logger resourceLogic *logic.ResourceLogic versionLogic *logic.VersionLogic - storageLogic *logic.StorageLogic } func NewVersionHandler( @@ -36,14 +35,12 @@ func NewVersionHandler( logger *zap.Logger, resourceLogic *logic.ResourceLogic, versionLogic *logic.VersionLogic, - storageLogic *logic.StorageLogic, ) *VersionHandler { return &VersionHandler{ conf: conf, logger: logger, resourceLogic: resourceLogic, versionLogic: versionLogic, - storageLogic: storageLogic, } } @@ -239,7 +236,7 @@ func (h *VersionHandler) Create(c *fiber.Ctx) error { Name: name, UploadArchivePath: tempPath, } - version, saveDir, err := h.versionLogic.Create(ctx, createVersionParam) + version, err := h.versionLogic.Create(ctx, createVersionParam) if err != nil { h.logger.Error("Failed to create version", zap.Error(err), @@ -248,19 +245,6 @@ func (h *VersionHandler) Create(c *fiber.Ctx) error { return c.Status(fiber.StatusInternalServerError).JSON(resp) } - createStorageParam := CreateStorageParam{ - VersionID: version.ID, - Directory: saveDir, - } - _, err = h.storageLogic.Create(ctx, createStorageParam) - if err != nil { - h.logger.Error("Failed to create storage", - zap.Error(err), - ) - resp := response.UnexpectedError() - return c.Status(fiber.StatusInternalServerError).JSON(resp) - } - data := CreateVersionResponseData{ ID: version.ID, Name: version.Name, diff --git a/internal/logic/resource.go b/internal/logic/resource.go index a47ddba..5b70437 100644 --- a/internal/logic/resource.go +++ b/internal/logic/resource.go @@ -4,71 +4,29 @@ import ( "context" . "github.com/MirrorChyan/resource-backend/internal/model" + "github.com/MirrorChyan/resource-backend/internal/repo" "github.com/MirrorChyan/resource-backend/internal/ent" - "github.com/MirrorChyan/resource-backend/internal/ent/resource" "go.uber.org/zap" ) type ResourceLogic struct { - logger *zap.Logger - db *ent.Client + logger *zap.Logger + resourceRepo *repo.Resource } -func NewResourceLogic(logger *zap.Logger, db *ent.Client) *ResourceLogic { +func NewResourceLogic(logger *zap.Logger, resourceRepo *repo.Resource) *ResourceLogic { return &ResourceLogic{ - logger: logger, - db: db, + logger: logger, + resourceRepo: resourceRepo, } } func (l *ResourceLogic) Create(ctx context.Context, param CreateResourceParam) (*ent.Resource, error) { - return l.db.Resource.Create(). - SetID(param.ID). - SetName(param.Name). - SetDescription(param.Description). - Save(ctx) + return l.resourceRepo.CreateResource(ctx, param.ID, param.Name, param.Description) } func (l *ResourceLogic) Exists(ctx context.Context, id string) (bool, error) { - return l.db.Resource.Query(). - Where(resource.ID(id)). - Exist(ctx) -} - -func (l *ResourceLogic) GetByID(ctx context.Context, id string) (*ent.Resource, error) { - return l.db.Resource.Get(ctx, id) -} - -func (l *ResourceLogic) List(ctx context.Context, param ListVersionParam) (int, []*ent.Resource, error) { - query := l.db.Resource.Query() - - count, err := query.Count(ctx) - if err != nil { - return 0, nil, err - } - - resources, err := query. - Offset(param.Offset). - Limit(param.Limit). - All(ctx) - if err != nil { - return 0, nil, err - } - - return count, resources, nil -} - -func (l *ResourceLogic) Update(ctx context.Context, param UpdateResourceParam) (*ent.Resource, error) { - return l.db.Resource.UpdateOneID(param.ID). - SetName(param.Name). - SetDescription(param.Description). - Save(ctx) -} - -func (l *ResourceLogic) Delete(ctx context.Context, id string) error { - return l.db.Resource. - DeleteOneID(id). - Exec(ctx) + return l.resourceRepo.CheckResourceExistsByID(ctx, id) } diff --git a/internal/logic/storage.go b/internal/logic/storage.go deleted file mode 100644 index 9161b10..0000000 --- a/internal/logic/storage.go +++ /dev/null @@ -1,35 +0,0 @@ -package logic - -import ( - "context" - "github.com/MirrorChyan/resource-backend/internal/ent" - "github.com/MirrorChyan/resource-backend/internal/ent/storage" - "github.com/MirrorChyan/resource-backend/internal/ent/version" - . "github.com/MirrorChyan/resource-backend/internal/model" - "go.uber.org/zap" -) - -type StorageLogic struct { - logger *zap.Logger - db *ent.Client -} - -func NewStorageLogic(logger *zap.Logger, db *ent.Client) *StorageLogic { - return &StorageLogic{ - logger: logger, - db: db, - } -} - -func (l *StorageLogic) Create(ctx context.Context, param CreateStorageParam) (*ent.Storage, error) { - return l.db.Storage.Create(). - SetVersionID(param.VersionID). - SetDirectory(param.Directory). - Save(ctx) -} - -func (l *StorageLogic) GetByVersionID(ctx context.Context, versionID int) (*ent.Storage, error) { - return l.db.Storage.Query(). - Where(storage.HasVersionWith(version.ID(versionID))). - Only(ctx) -} diff --git a/internal/logic/version.go b/internal/logic/version.go index 87ca1bb..4a0cb7f 100644 --- a/internal/logic/version.go +++ b/internal/logic/version.go @@ -9,232 +9,191 @@ import ( "strings" "github.com/MirrorChyan/resource-backend/internal/ent" - "github.com/MirrorChyan/resource-backend/internal/ent/resource" - "github.com/MirrorChyan/resource-backend/internal/ent/version" . "github.com/MirrorChyan/resource-backend/internal/model" "github.com/MirrorChyan/resource-backend/internal/patcher" "github.com/MirrorChyan/resource-backend/internal/pkg/archive" "github.com/MirrorChyan/resource-backend/internal/pkg/filehash" "github.com/MirrorChyan/resource-backend/internal/pkg/fileops" "github.com/MirrorChyan/resource-backend/internal/pkg/stg" + "github.com/MirrorChyan/resource-backend/internal/repo" "go.uber.org/zap" ) type VersionLogic struct { - logger *zap.Logger - db *ent.Client - storage *stg.Storage - storageLogic *StorageLogic + logger *zap.Logger + versionRepo *repo.Version + storageRepo *repo.Storage + storage *stg.Storage } -func NewVersionLogic(logger *zap.Logger, db *ent.Client, storage *stg.Storage, storageLogic *StorageLogic) *VersionLogic { +func NewVersionLogic(logger *zap.Logger, versionRepo *repo.Version, storageRepo *repo.Storage, storage *stg.Storage) *VersionLogic { return &VersionLogic{ - logger: logger, - db: db, - storage: storage, - storageLogic: storageLogic, + logger: logger, + versionRepo: versionRepo, + storageRepo: storageRepo, + storage: storage, } } func (l *VersionLogic) NameExists(ctx context.Context, param VersionNameExistsParam) (bool, error) { - return l.db.Version.Query(). - Where(version.HasResourceWith(resource.ID(param.ResourceID))). - Where(version.Name(param.Name)). - Exist(ctx) + return l.versionRepo.CheckVersionExistsByName(ctx, param.ResourceID, param.Name) } func (l *VersionLogic) GetLatest(ctx context.Context, resourceID string) (*ent.Version, error) { - return l.db.Version.Query(). - Where(version.HasResourceWith(resource.ID(resourceID))). - Order(ent.Desc("number")). - First(ctx) + return l.versionRepo.GetLatestVersion(ctx, resourceID) } -func (l *VersionLogic) Create(ctx context.Context, param CreateVersionParam) (*ent.Version, string, error) { - tx, err := l.db.Tx(ctx) - if err != nil { - l.logger.Error("Failed to start transaction", - zap.Error(err), - ) - return nil, "", err - } - +func (l *VersionLogic) Create(ctx context.Context, param CreateVersionParam) (*ent.Version, error) { var number uint64 - latest, err := tx.Version.Query(). - Where(version.HasResourceWith(resource.ID(param.ResourceID))). - Order(ent.Desc("number")). - First(ctx) + latest, err := l.versionRepo.GetLatestVersion(ctx, param.ResourceID) if ent.IsNotFound(err) { number = 1 } else if err != nil { l.logger.Error("Failed to query latest version", zap.Error(err), ) - return nil, "", err + return nil, err } if latest != nil { number = latest.Number + 1 } - v, err := tx.Version.Create(). - SetResourceID(param.ResourceID). - SetName(param.Name). - SetNumber(number). - Save(ctx) - if err != nil { - l.logger.Error("Failed to create version", - zap.Error(err), - ) - return l.createRollback(tx, err) - } - cwd, err := os.Getwd() - if err != nil { - l.logger.Error("Failed to get current working directory", - zap.Error(err), - ) - return l.createRollback(tx, err) - } - storageRootDir := filepath.Join(cwd, "storage") - versionDir := filepath.Join(storageRootDir, param.ResourceID, strconv.Itoa(v.ID)) - saveDir := filepath.Join(versionDir, "resource") - if err := os.MkdirAll(saveDir, os.ModePerm); err != nil { - l.logger.Error("Failed to create storage directory", - zap.Error(err), - ) - return l.createRollback(tx, err) - } + var ver *ent.Version - if strings.HasSuffix(param.UploadArchivePath, ".zip") { - err = archive.UnpackZip(param.UploadArchivePath, saveDir) - } else if strings.HasSuffix(param.UploadArchivePath, ".tar.gz") { - err = archive.UnpackTarGz(param.UploadArchivePath, saveDir) - } else { - l.logger.Error("Unknown archive extension", - zap.String("archive path", param.UploadArchivePath), - ) - err = fmt.Errorf("Unknown archive extension") - return l.createRollback(tx, err) - } + err = l.versionRepo.WithTx(ctx, func(tx *ent.Tx) error { + ver, err = l.versionRepo.CreateVersion(ctx, tx, param.ResourceID, param.Name, number) + if err != nil { + l.logger.Error("Failed to start transaction", + zap.Error(err), + ) + return err + } - if err != nil { - l.logger.Error("Failed to unpack file", - zap.String("version name", param.Name), - zap.Error(err), - ) - return l.createRollbackRemoveSaveDir(tx, err, saveDir) - } + versionDir := l.storage.VersionDir(param.ResourceID, ver.ID) + saveDir := filepath.Join(versionDir, "resource") + if err := os.MkdirAll(saveDir, os.ModePerm); err != nil { + l.logger.Error("Failed to create storage directory", + zap.String("directory", saveDir), + zap.Error(err), + ) + return err + } + + if strings.HasSuffix(param.UploadArchivePath, ".zip") { + err = archive.UnpackZip(param.UploadArchivePath, saveDir) + } else if strings.HasSuffix(param.UploadArchivePath, ".tar.gz") { + err = archive.UnpackTarGz(param.UploadArchivePath, saveDir) + } else { + l.logger.Error("Unknown archive extension", + zap.String("archive path", param.UploadArchivePath), + ) + err = fmt.Errorf("Unknown archive extension") + return err + } + + tx.OnRollback(func(next ent.Rollbacker) ent.Rollbacker { + return ent.RollbackFunc(func(ctx context.Context, tx *ent.Tx) error { + // Code before the actual rollback. + + rmErr := os.RemoveAll(saveDir) + if rmErr != nil { + l.logger.Error("Failed to remove storage directory", + zap.Error(rmErr), + ) + } + + err := next.Rollback(ctx, tx) + // Code after the transaction was rolled back. + + return err + }) + }) - archivePath := filepath.Join(versionDir, "resource.zip") - if strings.HasSuffix(param.UploadArchivePath, ".zip") { - err = fileops.MoveFile(param.UploadArchivePath, archivePath) if err != nil { - l.logger.Error("Failed to move archive file", - zap.String("origin path", param.UploadArchivePath), - zap.String("destination path", archivePath), + l.logger.Error("Failed to unpack file", + zap.String("version name", param.Name), zap.Error(err), ) - return l.createRollbackRemoveSaveDir(tx, err, saveDir) + return err } - } else { - if err := os.Remove(param.UploadArchivePath); err != nil { - l.logger.Error("Failed to remove temp file", + + archivePath := filepath.Join(versionDir, "resource.zip") + if strings.HasSuffix(param.UploadArchivePath, ".zip") { + err = fileops.MoveFile(param.UploadArchivePath, archivePath) + if err != nil { + l.logger.Error("Failed to move archive file", + zap.String("origin path", param.UploadArchivePath), + zap.String("destination path", archivePath), + zap.Error(err), + ) + return err + } + } else { + if err := os.Remove(param.UploadArchivePath); err != nil { + l.logger.Error("Failed to remove temp file", + zap.Error(err), + ) + return err + } + err = archive.CompressToZip(saveDir, archivePath) + if err != nil { + l.logger.Error("Failed to compress to zip", + zap.String("src dir", saveDir), + zap.String("dst file", archivePath), + zap.Error(err), + ) + return err + } + + } + + fileHashes, err := filehash.GetAll(saveDir) + if err != nil { + l.logger.Error("Failed to get file hashes", + zap.String("version name", param.Name), zap.Error(err), ) - return l.createRollbackRemoveSaveDir(tx, err, saveDir) + return err } - err = archive.CompressToZip(saveDir, archivePath) + ver, err = l.versionRepo.SetVersionFileHashesByOne(ctx, tx, ver, fileHashes) if err != nil { - l.logger.Error("Failed to compress to zip", - zap.String("src dir", saveDir), - zap.String("dst file", archivePath), + l.logger.Error("Failed to add file hashes to version", zap.Error(err), ) - return l.createRollbackRemoveSaveDir(tx, err, saveDir) + return err } - } + stg, err := l.storageRepo.CreateStorage(ctx, tx, saveDir) + if err != nil { + l.logger.Error("Failed to create storage", + zap.Error(err), + ) + return err + } - fileHashes, err := filehash.GetAll(saveDir) - if err != nil { - l.logger.Error("Failed to get file hashes", - zap.String("version name", param.Name), - zap.Error(err), - ) - return l.createRollbackRemoveSaveDir(tx, err, saveDir) - } - v, err = tx.Version.UpdateOne(v). - SetFileHashes(fileHashes). - Save(ctx) - if err != nil { - l.logger.Error("Failed to add file hashes to version", - zap.Error(err), - ) - return l.createRollbackRemoveSaveDir(tx, err, saveDir) - } + ver, err = l.versionRepo.SetVersionStorageByOne(ctx, tx, ver, stg) + if err != nil { + l.logger.Error("Failed to add storage to version", + zap.Error(err), + ) + return err + } + + return nil + }) - err = tx.Commit() if err != nil { l.logger.Error("Failed to commit transaction", zap.Error(err), ) - return nil, "", err + return nil, err } - return v, saveDir, nil -} - -func (l *VersionLogic) createRollback(tx *ent.Tx, err error) (*ent.Version, string, error) { - if rerr := tx.Rollback(); rerr != nil { - l.logger.Error("Failed to rollback transaction", - zap.Error(err), - ) - err = fmt.Errorf("%w: %v", err, rerr) - } - return nil, "", err -} - -func (l *VersionLogic) createRollbackRemoveSaveDir(tx *ent.Tx, err error, saveDir string) (*ent.Version, string, error) { - rmerr := os.RemoveAll(saveDir) - if rmerr != nil { - l.logger.Error("Failed to remove storage directory", - zap.Error(rmerr), - ) - err = fmt.Errorf("%w: %v", err, rmerr) - } - return l.createRollback(tx, err) -} - -func (l *VersionLogic) List(ctx context.Context, param ListVersionParam) (int, []*ent.Version, error) { - query := l.db.Version.Query(). - Where(version.HasResourceWith(resource.ID(param.ResourceID))) - - count, err := query.Count(ctx) - if err != nil { - return 0, nil, err - } - - versions, err := query. - Offset(param.Offset). - Limit(param.Limit). - Order(ent.Desc("number")). - All(ctx) - if err != nil { - return 0, nil, err - } - - return count, versions, nil + return ver, nil } func (l *VersionLogic) GetByName(ctx context.Context, param GetVersionByNameParam) (*ent.Version, error) { - return l.db.Version.Query(). - Where(version.HasResourceWith(resource.ID(param.ResourceID)), version.Name(param.Name)). - First(ctx) -} - -func (l *VersionLogic) Delete(ctx context.Context, id int) error { - return l.db.Version. - DeleteOneID(id). - Exec(ctx) + return l.versionRepo.GetVersionByName(ctx, param.ResourceID, param.Name) } func (l *VersionLogic) GetResourcePath(param GetResourcePathParam) string { @@ -270,7 +229,7 @@ func (l *VersionLogic) GetPatchPath(ctx context.Context, param GetVersionPatchPa } patchDir := l.storage.PatchDir(param.ResourceID, param.TargetVersionID) - latestStorage, err := l.storageLogic.GetByVersionID(ctx, param.TargetVersionID) + latestStorage, err := l.storageRepo.GetStorageByVersionID(ctx, param.TargetVersionID) if err != nil { l.logger.Error("Failed to get storage", zap.Error(err), diff --git a/internal/pkg/stg/storage.go b/internal/pkg/stg/storage.go index cf7a9e8..c45cd92 100644 --- a/internal/pkg/stg/storage.go +++ b/internal/pkg/stg/storage.go @@ -22,6 +22,10 @@ func (s *Storage) ResourcePath(resID string, verID int) string { return filepath.Join(s.rootDir, resID, strconv.Itoa(verID), "resource.zip") } +func (s *Storage) VersionDir(resID string, verID int) string { + return filepath.Join(s.rootDir, resID, strconv.Itoa(verID)) +} + func (s *Storage) PatchDir(resID string, targetVerID int) string { return filepath.Join(s.rootDir, resID, strconv.Itoa(targetVerID), "patch") } diff --git a/internal/repo/repo.go b/internal/repo/repo.go new file mode 100644 index 0000000..4eb58b2 --- /dev/null +++ b/internal/repo/repo.go @@ -0,0 +1,40 @@ +package repo + +import ( + "context" + "errors" + "fmt" + + "github.com/MirrorChyan/resource-backend/internal/ent" +) + +type Repo struct { + db *ent.Client +} + +func (r *Repo) WithTx(ctx context.Context, fn func(tx *ent.Tx) error) error { + tx, err := r.db.Tx(ctx) + if err != nil { + return err + } + + defer func() { + if r := recover(); r != nil { + _ = tx.Rollback() + panic(r) + } + }() + + if err := fn(tx); err != nil { + if rerr := tx.Rollback(); rerr != nil { + err = errors.Join(err, fmt.Errorf("rolling back transaction: %v", rerr)) + } + return err + } + + if err := tx.Commit(); err != nil { + return err + } + + return nil +} diff --git a/internal/repo/resource.go b/internal/repo/resource.go new file mode 100644 index 0000000..399c931 --- /dev/null +++ b/internal/repo/resource.go @@ -0,0 +1,32 @@ +package repo + +import ( + "context" + + "github.com/MirrorChyan/resource-backend/internal/ent" + "github.com/MirrorChyan/resource-backend/internal/ent/resource" +) + +type Resource struct { + db *ent.Client +} + +func NewResource(db *ent.Client) *Resource { + return &Resource{ + db: db, + } +} + +func (r *Resource) CreateResource(ctx context.Context, resID, name, description string) (*ent.Resource, error) { + return r.db.Resource.Create(). + SetID(resID). + SetName(name). + SetDescription(description). + Save(ctx) +} + +func (r *Resource) CheckResourceExistsByID(ctx context.Context, id string) (bool, error) { + return r.db.Resource.Query(). + Where(resource.ID(id)). + Exist(ctx) +} diff --git a/internal/repo/storage.go b/internal/repo/storage.go new file mode 100644 index 0000000..55990e2 --- /dev/null +++ b/internal/repo/storage.go @@ -0,0 +1,31 @@ +package repo + +import ( + "context" + + "github.com/MirrorChyan/resource-backend/internal/ent" + "github.com/MirrorChyan/resource-backend/internal/ent/storage" + "github.com/MirrorChyan/resource-backend/internal/ent/version" +) + +type Storage struct { + db *ent.Client +} + +func NewStorage(db *ent.Client) *Storage { + return &Storage{ + db: db, + } +} + +func (r *Storage) CreateStorage(ctx context.Context, tx *ent.Tx, dir string) (*ent.Storage, error) { + return tx.Storage.Create(). + SetDirectory(dir). + Save(ctx) +} + +func (r *Storage) GetStorageByVersionID(ctx context.Context, verID int) (*ent.Storage, error) { + return r.db.Storage.Query(). + Where(storage.HasVersionWith(version.ID(verID))). + Only(ctx) +} diff --git a/internal/repo/version.go b/internal/repo/version.go new file mode 100644 index 0000000..0f32176 --- /dev/null +++ b/internal/repo/version.go @@ -0,0 +1,62 @@ +package repo + +import ( + "context" + + "github.com/MirrorChyan/resource-backend/internal/ent" + "github.com/MirrorChyan/resource-backend/internal/ent/resource" + "github.com/MirrorChyan/resource-backend/internal/ent/version" +) + +type Version struct { + *Repo + db *ent.Client +} + +func NewVersion(db *ent.Client) *Version { + return &Version{ + Repo: &Repo{db: db}, + db: db, + } +} + +func (r *Version) CheckVersionExistsByName(ctx context.Context, resID, name string) (bool, error) { + return r.db.Version.Query(). + Where(version.HasResourceWith(resource.ID(resID))). + Where(version.Name(name)). + Exist(ctx) +} + +func (r *Version) GetVersionByName(ctx context.Context, resID, name string) (*ent.Version, error) { + return r.db.Version.Query(). + Where(version.HasResourceWith(resource.ID(resID))). + Where(version.Name(name)). + First(ctx) +} + +func (r *Version) GetLatestVersion(ctx context.Context, resID string) (*ent.Version, error) { + return r.db.Version.Query(). + Where(version.HasResourceWith(resource.ID(resID))). + Order(ent.Desc(version.FieldNumber)). + First(ctx) +} + +func (r *Version) CreateVersion(ctx context.Context, tx *ent.Tx, resID, name string, number uint64) (*ent.Version, error) { + return tx.Version.Create(). + SetResourceID(resID). + SetName(name). + SetNumber(number). + Save(ctx) +} + +func (r *Version) SetVersionFileHashesByOne(ctx context.Context, tx *ent.Tx, ver *ent.Version, fileHashes map[string]string) (*ent.Version, error) { + return tx.Version.UpdateOne(ver). + SetFileHashes(fileHashes). + Save(ctx) +} + +func (r *Version) SetVersionStorageByOne(ctx context.Context, tx *ent.Tx, ver *ent.Version, stg *ent.Storage) (*ent.Version, error) { + return tx.Version.UpdateOne(ver). + SetStorage(stg). + Save(ctx) +} diff --git a/internal/wire/wire.go b/internal/wire/wire.go index d93aa61..e170b7f 100644 --- a/internal/wire/wire.go +++ b/internal/wire/wire.go @@ -9,17 +9,23 @@ import ( "github.com/MirrorChyan/resource-backend/internal/handler" "github.com/MirrorChyan/resource-backend/internal/logic" "github.com/MirrorChyan/resource-backend/internal/pkg/stg" + "github.com/MirrorChyan/resource-backend/internal/repo" "github.com/google/wire" "go.uber.org/zap" ) -var logicSet = wire.NewSet( +var repoProviderSet = wire.NewSet( + repo.NewResource, + repo.NewVersion, + repo.NewStorage, +) + +var logicProviderSet = wire.NewSet( logic.NewResourceLogic, logic.NewVersionLogic, - logic.NewStorageLogic, ) -var handlerSet = wire.NewSet( +var handlerProviderSet = wire.NewSet( handler.NewResourceHandler, handler.NewVersionHandler, ) @@ -29,7 +35,7 @@ type HandlerSet struct { VersionHandler *handler.VersionHandler } -func newHandlerSet(resourceHandler *handler.ResourceHandler, versionHandler *handler.VersionHandler) *HandlerSet { +func provideHandlerSet(resourceHandler *handler.ResourceHandler, versionHandler *handler.VersionHandler) *HandlerSet { return &HandlerSet{ ResourceHandler: resourceHandler, VersionHandler: versionHandler, @@ -37,5 +43,5 @@ func newHandlerSet(resourceHandler *handler.ResourceHandler, versionHandler *han } func NewHandlerSet(conf *config.Config, logger *zap.Logger, db *ent.Client, storage *stg.Storage) *HandlerSet { - panic(wire.Build(logicSet, handlerSet, newHandlerSet)) + panic(wire.Build(repoProviderSet, logicProviderSet, handlerProviderSet, provideHandlerSet)) } diff --git a/internal/wire/wire_gen.go b/internal/wire/wire_gen.go index 4edc6d5..bce403c 100644 --- a/internal/wire/wire_gen.go +++ b/internal/wire/wire_gen.go @@ -12,6 +12,7 @@ import ( "github.com/MirrorChyan/resource-backend/internal/handler" "github.com/MirrorChyan/resource-backend/internal/logic" "github.com/MirrorChyan/resource-backend/internal/pkg/stg" + "github.com/MirrorChyan/resource-backend/internal/repo" "github.com/google/wire" "go.uber.org/zap" ) @@ -19,27 +20,31 @@ import ( // Injectors from wire.go: func NewHandlerSet(conf *config.Config, logger *zap.Logger, db *ent.Client, storage *stg.Storage) *HandlerSet { - resourceLogic := logic.NewResourceLogic(logger, db) + resource := repo.NewResource(db) + resourceLogic := logic.NewResourceLogic(logger, resource) resourceHandler := handler.NewResourceHandler(logger, resourceLogic) - storageLogic := logic.NewStorageLogic(logger, db) - versionLogic := logic.NewVersionLogic(logger, db, storage, storageLogic) - versionHandler := handler.NewVersionHandler(conf, logger, resourceLogic, versionLogic, storageLogic) - wireHandlerSet := newHandlerSet(resourceHandler, versionHandler) - return wireHandlerSet + version := repo.NewVersion(db) + repoStorage := repo.NewStorage(db) + versionLogic := logic.NewVersionLogic(logger, version, repoStorage, storage) + versionHandler := handler.NewVersionHandler(conf, logger, resourceLogic, versionLogic) + handlerSet := provideHandlerSet(resourceHandler, versionHandler) + return handlerSet } // wire.go: -var logicSet = wire.NewSet(logic.NewResourceLogic, logic.NewVersionLogic, logic.NewStorageLogic) +var repoProviderSet = wire.NewSet(repo.NewResource, repo.NewVersion, repo.NewStorage) -var handlerSet = wire.NewSet(handler.NewResourceHandler, handler.NewVersionHandler) +var logicProviderSet = wire.NewSet(logic.NewResourceLogic, logic.NewVersionLogic) + +var handlerProviderSet = wire.NewSet(handler.NewResourceHandler, handler.NewVersionHandler) type HandlerSet struct { ResourceHandler *handler.ResourceHandler VersionHandler *handler.VersionHandler } -func newHandlerSet(resourceHandler *handler.ResourceHandler, versionHandler *handler.VersionHandler) *HandlerSet { +func provideHandlerSet(resourceHandler *handler.ResourceHandler, versionHandler *handler.VersionHandler) *HandlerSet { return &HandlerSet{ ResourceHandler: resourceHandler, VersionHandler: versionHandler,