1
package user
2

3
import "github.com/google/wire"
4

5
// ProviderSet 包含了 user 模块所有的依赖
6
var ProviderSet = wire.NewSet(
7
    // 提供应用层(仅示例，未给出具体代码)
8
    NewUserService,
9

10
    // 提供数据层(仅示例，未给出具体代码)
11
    NewUserRepo,
12

13
    // 绑定接口与实现 (这是在模块内部完成的，外部不知道细节)
14
    // 告诉 Wire: 当 NewUserService 需要 UserRepository 接口时，使用 UserPgRepo 这个 struct 来填充。
15
    wire.Bind(new(UserRepository), new(*UserRepo)),
16

17
    // 提供接口层 Handler
18
    NewUserHandler,
19
)

1
//go:build wireinject
2
// +build wireinject
3
// 上面这两行注释必不可少，用于wire识别。
4

5
package main
6

7
import (
8
  "github.com/google/wire"
9
  "my-project/internal/user"   // 导入 user 模块
10
  "my-project/internal/pkg/db" // 导入共享的 DB 连接
11
)
12

13
// initializeApp 注入器，拼积木
14
func initializeApp() (*App, func(), error) {
15
  panic(wire.Build(
16
    // 一些共享的基础设施
17
        conf.ProviderSet,
18
        logger.ProviderSet,
19
    db.ProviderSet,
20
        ...
21
    // 业务模块
22
    user.ProviderSet,
23
        ...
24
    // App 的构造函数
25
    NewApp,
26
  ))
27
}

1
{
2
  "$schema": "https://raw.githubusercontent.com/jetify-com/devbox/main/.schema/devbox.schema.json",
3
  "packages": [
4
    "go@1.23",
5
    "postgresql@16",
6
    "redis@7",
7
    "protobuf@28",
8
    "buf@latest",
9
    "sqlc@latest",
10
    "go-task@latest",
11
    "golangci-lint@latest"
12
  ],
13
  "shell": {
14
    "init_hook": [
15
      "echo 'Welcome to my-project dev environment!'",
16
      "export GOPATH=$HOME/go",
17
      "export PATH=$PATH:$GOPATH/bin"
18
    ],
19
    "scripts": {
20
      "dev": "task dev",
21
      "test": "task test",
22
      "generate": "task generate"
23
    }
24
  }
25
}

1
server:
2
  http:
3
    addr: :8000
4
    timeout: 1s
5
  grpc:
6
    addr: :9000
7

8
data:
9
  database:
10
    driver: postgres
11
    source: postgres://user:pass@localhost:5432/mydb?sslmode=disable
12
  redis:
13
    addr: 127.0.0.1:6379
14
    password: ""
15

16
log:
17
  level: debug
18
  filename: "app.log"

1
package conf
2

3
import (
4
  "github.com/spf13/viper"
5
  "strings"
6
)
7

8
// Bootstrap 是所有配置的根节点
9
type Bootstrap struct {
10
  Server *Server `mapstructure:"server"`
11
  Data   *Data   `mapstructure:"data"`
12
  Log    *Log    `mapstructure:"log"`
63 collapsed lines
13
}
14

15
type Server struct {
16
  Http *Http `mapstructure:"http"`
17
  Grpc *Grpc `mapstructure:"grpc"`
18
}
19

20
type Http struct {
21
  Addr    string `mapstructure:"addr"`
22
  Timeout string `mapstructure:"timeout"`
23
}
24

25
type Grpc struct {
26
  Addr string `mapstructure:"addr"`
27
}
28

29
type Data struct {
30
  Database *Database `mapstructure:"database"`
31
  Redis    *Redis    `mapstructure:"redis"`
32
}
33

34
type Database struct {
35
  Driver string `mapstructure:"driver"`
36
  Source string `mapstructure:"source"`
37
}
38

39
type Redis struct {
40
  Addr     string `mapstructure:"addr"`
41
  Password string `mapstructure:"password"`
42
}
43

44
type Log struct {
45
  Level    string `mapstructure:"level"`
46
  Filename string `mapstructure:"filename"`
47
}
48

49
// Load 加载配置
50
// path: 配置文件路径，例如 "./configs/config.yaml"
51
func Load(path string) (*Bootstrap, error) {
52
  v := viper.New()
53

54
  // 设置配置文件路径
55
  v.SetConfigFile(path)
56

57
  // 允许环境变量覆盖 (对 Docker/K8s 等部署非常重要)
58
    // 例如：export APP_DATA_DATABASE_SOURCE="xxx" 可以覆盖 yaml 里的配置
59
  v.AutomaticEnv()
60
    // 将 . 替换为 _ (环境变量通常不允许有点)
61
  v.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
62
    // 设置环境变量前缀，防止冲突，例如 APP_SERVER_HTTP_ADDR
63
    v.SetEnvPrefix("APP")
64

65
  // 读取配置
66
  if err := v.ReadInConfig(); err != nil {
67
    return nil, err
68
  }
69

70
  // 将配置映射到结构体
71
  var c Bootstrap
72
  if err := v.Unmarshal(&c, func(dc *mapstructure.DecoderConfig) {
73
        dc.TagName = "json" // 或者 "yaml", "mapstructure"
74
    }); err != nil {
75
    return nil, err
76
  }
77

78
  return &c, nil
79
}

1
package conf
2

3
import "github.com/google/wire"
4

5
var ProviderSet = wire.NewSet(
6
    // 提供提取 Log 配置的方法
7
    func(c *Bootstrap) *Log { return c.Log },
8
    // 提供提取 Data 配置的方法
9
    func(c *Bootstrap) *Data { return c.Data },
10
    // 提供提取 Server 配置的方法
11
    func(c *Bootstrap) *Server { return c.Server },
12
    // ...
13
)

1
func main() {
2
    // 程序启动，先加载配置
3
    // 这里的路径可以通过命令行参数传入，更灵活
4
    cfg, err := conf.Load("./configs/config.yaml")
5
    if err != nil {
6
        panic(err)
7
    }
8

9
    // 传入配置，初始化 App
10
    app, cleanup, err := initApp(cfg)
11
    if err != nil {
12
        panic(err)
13
    }
14
    defer cleanup()
15

16
    // 启动
17
    app.Run()
18
}

1
package trace
2

3
import (
4
  "context"
5
  "time"
6

7
  "go.opentelemetry.io/otel"
8
  "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
9
  "go.opentelemetry.io/otel/propagation"
10
  "go.opentelemetry.io/otel/sdk/resource"
11
  sdktrace "go.opentelemetry.io/otel/sdk/trace"
12
  semconv "go.opentelemetry.io/otel/semconv/v1.17.0"
45 collapsed lines
13
)
14

15
// InitProvider 初始化 OpenTelemetry
16
// serviceName: 服务名称，如 "user-service"
17
// endpoint: 收集器地址，如 "localhost:4318" (Jaeger 的 OTLP http 端口)
18
func InitProvider(ctx context.Context, serviceName, endpoint string) (func(context.Context) error, error) {
19
  // 创建 Exporter (数据发送到哪里)
20
  // 这里使用 HTTP 协议发送到 Jaeger/Collector
21
  exporter, err := otlptracehttp.New(ctx,
22
    otlptracehttp.WithEndpoint(endpoint),
23
    otlptracehttp.WithInsecure(), // 本地测试通常不用 TLS
24
  )
25
  if err != nil {
26
    return nil, err
27
  }
28

29
  // 创建 Resource (标识当前服务身份)
30
  res, err := resource.New(ctx,
31
    resource.WithAttributes(
32
      semconv.ServiceName(serviceName),
33
      semconv.ServiceVersion(Version),
34
            attribute.String("git.commit", CommitHash),
35
            attribute.String("build.time", BuildTime),
36
    ),
37
  )
38
  if err != nil {
39
    return nil, err
40
  }
41

42
  // 创建 TraceProvider (核心管理器)
43
  tp := sdktrace.NewTracerProvider(
44
    sdktrace.WithBatcher(exporter), // 批量发送，性能更好
45
    sdktrace.WithResource(res),
46
    sdktrace.WithSampler(sdktrace.AlwaysSample()), // 采样率：100% (生产环境建议调低)
47
  )
48

49
  // 设置全局 Provider
50
  otel.SetTracerProvider(tp)
51

52
  // 设置全局 Propagator (传播格式)
53
  // W3C TraceContext 是现在的标准，能在不同语言/框架间传递 TraceID
54
  otel.SetTextMapPropagator(propagation.NewCompositeTextMapPropagator(
55
    propagation.TraceContext{},
56
    propagation.Baggage{},
57
  ))
58

59
  // 返回关闭函数，用于在 main 中平滑退出
60
  return tp.Shutdown, nil
61
}

1
package logger
2

3
import (
4
  "context"
5
  "log/slog"
6
  "net/http"
7
  "os"
8

9
  "go.opentelemetry.io/otel/trace"
10
  "go.uber.org/zap"
11
  "go.uber.org/zap/exp/zapslog"
12
  "go.uber.org/zap/zapcore"
107 collapsed lines
13
  "gopkg.in/natefinch/lumberjack.v2"
14
)
15

16
// Config 日志配置
17
type Config struct {
18
  Level      string // debug, info, warn, error
19
  Filename   string // 日志文件路径，为空则只输出到控制台
20
  MaxSize    int    // 单个文件最大尺寸 (MB)
21
  MaxBackups int    // 保留旧文件最大个数
22
  MaxAge     int    // 保留旧文件最大天数
23
  Compress   bool   // 是否压缩
24
}
25

26
// Init 初始化全局 slog
27
func Init(cfg *Config) {
28
  // 设置日志级别
29
  atomicLevel := zap.NewAtomicLevel()
30
  switch cfg.Level {
31
  case "debug":
32
    atomicLevel.SetLevel(zap.DebugLevel)
33
  case "warn":
34
    atomicLevel.SetLevel(zap.WarnLevel)
35
  case "error":
36
    atomicLevel.SetLevel(zap.ErrorLevel)
37
  default:
38
    atomicLevel.SetLevel(zap.InfoLevel)
39
  }
40

41
  // Encoder (格式化)
42
  encoderConfig := zap.NewProductionEncoderConfig()
43
  encoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder   // 时间格式: 2026-01-13T12:00:00.000Z
44
  encoderConfig.EncodeLevel = zapcore.CapitalLevelEncoder // 级别格式: INFO, ERROR
45

46
  var encoder zapcore.Encoder
47
  if cfg.Filename == "" {
48
    encoder = zapcore.NewConsoleEncoder(encoderConfig) // 本地开发: Console
49
  } else {
50
    encoder = zapcore.NewJSONEncoder(encoderConfig) // 生产环境: JSON
51
  }
52

53
  // 配置 WriteSyncer (输出位置)
54
  var writer zapcore.WriteSyncer
55
  if cfg.Filename == "" {
56
    writer = zapcore.AddSync(os.Stdout)
57
  } else {
58
    lumberJackLogger := &lumberjack.Logger{
59
      Filename:   cfg.Filename,
60
      MaxSize:    cfg.MaxSize,
61
      MaxBackups: cfg.MaxBackups,
62
      MaxAge:     cfg.MaxAge,
63
      Compress:   cfg.Compress,
64
    }
65
    // 双写：文件 + 控制台 (方便 Docker/K8s 采集)
66
    writer = zapcore.NewMultiWriteSyncer(
67
      zapcore.AddSync(lumberJackLogger),
68
      zapcore.AddSync(os.Stdout),
69
    )
70
  }
71

72
  // 创建 Zap Core
73
  core := zapcore.NewCore(encoder, writer, atomicLevel)
74
  zapLogger := zap.New(core, zap.AddCaller())
75

76
  // 将 Zap 转换为 Slog Handler
77
  // zapslog.NewHandler 会把 slog 的请求转给 zap 处理
78
  zapHandler := zapslog.NewHandler(zapLogger.Core(), nil)
79

80
  // 包装 TraceHandler (实现自动提取 TraceID)
81
  finalHandler := &TraceHandler{Handler: zapHandler}
82

83
  // 设置为全局默认 Logger
84
  // 之后在任何地方调用 slog.InfoContext() 都会经过这里
85
  slog.SetDefault(slog.New(finalHandler))
86
}
87

88
// ---------------------------------------------------------
89
// TraceHandler: Slog 中间件
90
// 用于从 Context 中提取 OTel TraceID 并注入到日志属性中
91
// ---------------------------------------------------------
92

93
type TraceHandler struct {
94
  slog.Handler
95
}
96

97
func (h *TraceHandler) Handle(ctx context.Context, r slog.Record) error {
98
  // 从 Context 提取 OpenTelemetry Span
99
  span := trace.SpanFromContext(ctx)
100
  if span.SpanContext().IsValid() {
101
    traceID := span.SpanContext().TraceID().String()
102
    spanID := span.SpanContext().SpanID().String()
103

104
    // 将 trace_id 和 span_id 添加到本次日志记录的属性中
105
    r.AddAttrs(
106
      slog.String("trace_id", traceID),
107
      slog.String("span_id", spanID),
108
    )
109
  }
110

111
  // 调用下一层 Handler (即 Zap)
112
  return h.Handler.Handle(ctx, r)
113
}
114

115
// WithAttrs 和 WithGroup 是 slog.Handler 接口必须实现的方法
116
// 透传给底层 handler
117
func (h *TraceHandler) WithAttrs(attrs []slog.Attr) slog.Handler {
118
  return &TraceHandler{Handler: h.Handler.WithAttrs(attrs)}
119
}
120

121
func (h *TraceHandler) WithGroup(name string) slog.Handler {
122
  return &TraceHandler{Handler: h.Handler.WithGroup(name)}
123
}

1
import (
2
    "github.com/riandyrn/otelchi"
3
)
4

5
func NewRouter() *chi.Mux {
6
    r := chi.NewRouter()
7

8
    // service-name 会显示在 Jaeger 的 Span 名称中
9
    r.Use(otelchi.Middleware("my-project"))
10

11
    // ... 其他路由
12
    return r
13
}

1
import (
2
    "github.com/jackc/pgx/v5/pgxpool"
3
    "github.com/exaring/otelpgx"
4
)
5

6
func NewDB(cfg *conf.Data) *pgxpool.Pool {
7
    poolConfig, _ := pgxpool.ParseConfig(cfg.Database.Source)
8

9
    // 安装 OTel 追踪器
10
    poolConfig.ConnConfig.Tracer = otelpgx.NewTracer()
11

12
    pool, _ := pgxpool.NewWithConfig(context.Background(), poolConfig)
13
    return pool
14
}

1
func main() {
2
    // 加载配置
3
  cfg, err := conf.Load("./configs/config.yaml")
4
  if err != nil {
5
    panic(err)
6
  }
7
    logger.Init(&logger.Config{
8
    Level:    cfg.Log.Level,
9
    Filename: cfg.Log.Filename,
10
    // ...
11
  })
12
    ctx, cancel := context.WithCancel(context.Background())
33 collapsed lines
13
  defer cancel()
14
  otelShutdown, err := trace.InitProvider(ctx, "my-server-name", cfg.Trace.Endpoint)
15
    if err != nil {
16
    // 启动时如果连不上监控系统，panic
17
    slog.Error("Failed to init OTel provider", "err", err)
18
    panic(err)
19
  }
20
    // 注册平滑退出的清理函数 (Defer LIFO 原则)
21
  defer func() {
22
    // 创建一个独立的 context 用于关闭操作，给予 5秒 超时
23
    shutdownCtx, shutdownCancel := context.WithTimeout(context.Background(), 5*time.Second)
24
    defer shutdownCancel()
25

26
    if err := otelShutdown(shutdownCtx); err != nil {
27
      slog.Error("Failed to shutdown TracerProvider", "err", err)
28
    } else {
29
      slog.Info("TracerProvider shutdown success")
30
    }
31
  }()
32

33
    // 初始化 Chi Router
34
  r := chi.NewRouter()
35

36
    // 注册核心中间件 (顺序非常重要)
37
    // A. OTel: 生成 TraceID (必须第一)
38
  r.Use(otelchi.Middleware("my-server-name"))
39

40
    // B. AccessLogger: 记录 HTTP 请求日志 (依赖 TraceID)
41
  r.Use(middleware.AccessLogger)
42

43
    // C. Recovery: 兜底 Panic (依赖 Logger 和 TraceID)，后面会在报错统一管理中提到
44
  r.Use(middleware.Recoverer)
45

46
    // .....后面省略
47

48
    // ... 启动 App ...
49
}

1
version: "3"
2
services:
3
  jaeger:
4
    image: jaegertracing/all-in-one:latest
5
    ports:
6
      - "16686:16686" # 前端 UI 端口
7
      - "4318:4318"   # OTLP HTTP 接收端口 (我们在 Go 代码里填的这个)
8
    environment:
9
      - LOG_LEVEL=debug

1
syntax = "proto3";
2

3
package user.v1;
4

5
option go_package = "my-project/gen/user/v1;userv1";
6

7
message GetUserRequest {
8
  int64 id = 1;
9
}
10

11
message GetUserResponse {
12
  int64 id = 1;
14 collapsed lines
13
  string username = 2;
14
  string email = 3;
15
}
16

17
message CreateUserRequest {
18
  string username = 1;
19
  string email = 2;
20
  string password = 3;
21
}
22

23
message CreateUserResponse {
24
  int64 id = 1;
25
}
26

27
service UserService {
28
  rpc GetUser(GetUserRequest) returns (GetUserResponse);
29
  rpc CreateUser(CreateUserRequest) returns (CreateUserResponse);
30
}

1
version: v2
2
plugins:
3
  - remote: buf.build/protocolbuffers/go
4
    out: gen
5
    opt: paths=source_relative
6
  - remote: buf.build/connectrpc/go
7
    out: gen
8
    opt: paths=source_relative

1
package user
2

3
import "github.com/google/wire"
4

5
var ProviderSet = wire.NewSet(
6
    NewUserRepo,
7
    NewUserService,
8
    // 对于handler，推荐直接使用，wire会自动注入。
9
    wire.Struct(new(Handler), "*"),
10
)

1
package server
2

3
import (
4
  "net/http"
5

6
  "connectrpc.com/connect"
7
  "github.com/go-chi/chi/v5"
8
  chimiddleware "github.com/go-chi/chi/v5/middleware"
9
  "github.com/riandyrn/otelchi"
10
  "golang.org/x/net/http2"
11
  "golang.org/x/net/http2/h2c"
12

56 collapsed lines
13
  "my-project/gen/user/v1/userv1connect"
14
  "my-project/gen/order/v1/orderv1connect"
15
  "my-project/internal/conf"
16
  "my-project/internal/middleware"
17
  "my-project/internal/user"
18
  "my-project/internal/order"
19
)
20

21
// HTTPServer 包装 http.Server
22
type HTTPServer struct {
23
  Server *http.Server
24
}
25

26
// 做一个集中入口函数
27
// Wire 会自动把 user.Handler, order.Handler 注入进来
28
func NewHTTPServer(
29
  cfg *conf.Server,              // 引入配置
30
  userHandler *user.Handler,     // 用户模块 Handler
31
  orderHandler *order.Handler,   // 订单模块 Handler
32
) *HTTPServer {
33

34
  r := chi.NewRouter()
35

36
  // 中间件
37
  r.Use(otelchi.Middleware("my-project"))
38
  r.Use(chimiddleware.RequestID)
39
  r.Use(middleware.AccessLogger)
40
  r.Use(middleware.Recoverer)
41

42
  // Connect-Go 拦截器 (用于统一错误处理、日志等)
43
  interceptors := connect.WithInterceptors(
44
    middleware.NewErrorInterceptor(),
45
    middleware.NewLoggingInterceptor(),
46
  )
47

48
  // 注册 Connect-Go 服务
49
  // 每个模块的 Handler 都在这里挂载
50
  userPath, userHandler := userv1connect.NewUserServiceHandler(userHandler, interceptors)
51
  r.Mount(userPath, userHandler)
52

53
  orderPath, orderHandler := orderv1connect.NewOrderServiceHandler(orderHandler, interceptors)
54
  r.Mount(orderPath, orderHandler)
55

56
  // 支持 HTTP/2 (Connect-Go 需要)
57
  srv := &http.Server{
58
    Addr:    cfg.Http.Addr,
59
    Handler: h2c.NewHandler(r, &http2.Server{}),
60
  }
61

62
  return &HTTPServer{Server: srv}
63
}
64

65
// Run 方法
66
func (s *HTTPServer) Run() error {
67
  return s.Server.ListenAndServe()
68
}
69
// Shutdown 方法
70
func (s *HTTPServer) Shutdown(ctx context.Context) error {
71
  return s.Server.Shutdown(ctx)
72
}

1
func initApp(cfg *conf.Bootstrap) (*App, func(), error) {
2
  panic(wire.Build(
3
    // 基础设施
4
    conf.ProviderSet,
5
    logger.ProviderSet,
6

7
    // 业务模块 (它们会提供 xxx.Handler)
8
    user.ProviderSet,
9
    order.ProviderSet,
10

11
    // Server 层 (消费 xxx.Handler)
12
    server.NewHTTPServer, // 这里会接收上面的 Handler 并生成 *HTTPServer
13

14
    // App 启动入口
15
    newApp,
16
  ))
17
}

1
model
2
  schema 1.1
3

4
type user
5

6
type document
7
  relations
8
    define owner: [user]
9
    define editor: [user] or owner
10
    define viewer: [user] or editor
11

12
type folder
13
  relations
14
    define owner: [user]
15
    define editor: [user] or owner
16
    define viewer: [user] or editor
17
    define parent: [folder]
18

19
  # 继承父文件夹的权限
20
  define can_view: viewer or can_view from parent
21
  define can_edit: editor or can_edit from parent
22

23
type organization
24
  relations
25
    define admin: [user]
26
    define member: [user] or admin

1
package authz
2

3
import (
4
  "context"
5
  "log/slog"
6

7
  openfga "github.com/openfga/go-sdk"
8
  "github.com/openfga/go-sdk/client"
9
  "my-project/internal/conf"
10
)
11

12
// Authorizer 授权检查器
85 collapsed lines
13
type Authorizer struct {
14
  client  *client.OpenFgaClient
15
  storeID string
16
}
17

18
// NewAuthorizer 构造函数
19
func NewAuthorizer(cfg *conf.Auth) (*Authorizer, error) {
20
  fgaClient, err := client.NewSdkClient(&client.ClientConfiguration{
21
    ApiUrl:  cfg.OpenFGA.ApiURL,  // 如 http://localhost:8080
22
    StoreId: cfg.OpenFGA.StoreID, // Store ID
23
  })
24
  if err != nil {
25
    return nil, err
26
  }
27

28
  return &Authorizer{
29
    client:  fgaClient,
30
    storeID: cfg.OpenFGA.StoreID,
31
  }, nil
32
}
33

34
// Check 检查权限
35
// user: "user:alice"
36
// relation: "viewer"
37
// object: "document:readme"
38
func (a *Authorizer) Check(ctx context.Context, user, relation, object string) (bool, error) {
39
  resp, err := a.client.Check(ctx).Body(client.ClientCheckRequest{
40
    User:     user,
41
    Relation: relation,
42
    Object:   object,
43
  }).Execute()
44

45
  if err != nil {
46
    slog.ErrorContext(ctx, "OpenFGA check failed", "err", err, "user", user, "relation", relation, "object", object)
47
    return false, err
48
  }
49

50
  return resp.GetAllowed(), nil
51
}
52

53
// WriteTuple 写入权限元组
54
func (a *Authorizer) WriteTuple(ctx context.Context, user, relation, object string) error {
55
  _, err := a.client.Write(ctx).Body(client.ClientWriteRequest{
56
    Writes: []client.ClientTupleKey{
57
      {
58
        User:     user,
59
        Relation: relation,
60
        Object:   object,
61
      },
62
    },
63
  }).Execute()
64

65
  if err != nil {
66
    slog.ErrorContext(ctx, "OpenFGA write failed", "err", err)
67
    return err
68
  }
69

70
  return nil
71
}
72

73
// DeleteTuple 删除权限元组
74
func (a *Authorizer) DeleteTuple(ctx context.Context, user, relation, object string) error {
75
  _, err := a.client.Write(ctx).Body(client.ClientWriteRequest{
76
    Deletes: []client.ClientTupleKeyWithoutCondition{
77
      {
78
        User:     user,
79
        Relation: relation,
80
        Object:   object,
81
      },
82
    },
83
  }).Execute()
84

85
  return err
86
}
87

88
// ListObjects 列出用户有权限的对象
89
func (a *Authorizer) ListObjects(ctx context.Context, user, relation, objectType string) ([]string, error) {
90
  resp, err := a.client.ListObjects(ctx).Body(client.ClientListObjectsRequest{
91
    User:     user,
92
    Relation: relation,
93
    Type:     objectType,
94
  }).Execute()
95

96
  if err != nil {
97
    return nil, err
98
  }
99

100
  return resp.GetObjects(), nil
101
}