*/config: add PLC URL config option #683

···

       
28
       
 
       
	Jwks string `env:"JWKS"`

     

       
29
       
 
       
}

     

       
30
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
31
       
 
       
type JetstreamConfig struct {

     

       
32
       
 
       
	Endpoint string `env:"ENDPOINT, default=wss://jetstream1.us-east.bsky.network/subscribe"`

     

       
33
       
 
       
}

     
···

       
103
       
 
       
	Avatar        AvatarConfig    `env:",prefix=TANGLED_AVATAR_"`

     

       
104
       
 
       
	OAuth         OAuthConfig     `env:",prefix=TANGLED_OAUTH_"`

     

       
105
       
 
       
	Redis         RedisConfig     `env:",prefix=TANGLED_REDIS_"`

     

       
0
       
 
       

     

       
106
       
 
       
	Pds           PdsConfig       `env:",prefix=TANGLED_PDS_"`

     

       
107
       
 
       
	Cloudflare    Cloudflare      `env:",prefix=TANGLED_CLOUDFLARE_"`

     

       
108
       
 
       
}

     

···

       
28
       
 
       
	Jwks string `env:"JWKS"`

     

       
29
       
 
       
}

     

       
30
       
 
       


     

       
31
       
+
       
type PlcConfig struct {

     

       
32
       
+
       
	PLCURL string `env:"URL, default=https://plc.directory"`

     

       
33
       
+
       
}

     

       
34
       
+
       


     

       
35
       
 
       
type JetstreamConfig struct {

     

       
36
       
 
       
	Endpoint string `env:"ENDPOINT, default=wss://jetstream1.us-east.bsky.network/subscribe"`

     

       
37
       
 
       
}

     
···

       
107
       
 
       
	Avatar        AvatarConfig    `env:",prefix=TANGLED_AVATAR_"`

     

       
108
       
 
       
	OAuth         OAuthConfig     `env:",prefix=TANGLED_OAUTH_"`

     

       
109
       
 
       
	Redis         RedisConfig     `env:",prefix=TANGLED_REDIS_"`

     

       
110
       
+
       
	Plc           PlcConfig       `env:",prefix=TANGLED_PLC_"`

     

       
111
       
 
       
	Pds           PdsConfig       `env:",prefix=TANGLED_PDS_"`

     

       
112
       
 
       
	Cloudflare    Cloudflare      `env:",prefix=TANGLED_CLOUDFLARE_"`

     

       
113
       
 
       
}

     

···

       
70
       
 
       
		return nil, fmt.Errorf("failed to create enforcer: %w", err)

     

       
71
       
 
       
	}

     

       
72
       
 
       


     

       
73
       
-
       
	res, err := idresolver.RedisResolver(config.Redis.ToURL())

     

       
74
       
 
       
	if err != nil {

     

       
75
       
 
       
		logger.Error("failed to create redis resolver", "err", err)

     

       
76
       
-
       
		res = idresolver.DefaultResolver()

     

       
77
       
 
       
	}

     

       
78
       
 
       


     

       
79
       
 
       
	posthog, err := posthog.NewWithConfig(config.Posthog.ApiKey, posthog.Config{Endpoint: config.Posthog.Endpoint})

     

···

       
70
       
 
       
		return nil, fmt.Errorf("failed to create enforcer: %w", err)

     

       
71
       
 
       
	}

     

       
72
       
 
       


     

       
73
       
+
       
	res, err := idresolver.RedisResolver(config.Redis.ToURL(), config.Plc.PLCURL)

     

       
74
       
 
       
	if err != nil {

     

       
75
       
 
       
		logger.Error("failed to create redis resolver", "err", err)

     

       
76
       
+
       
		res = idresolver.DefaultResolver(config.Plc.PLCURL)

     

       
77
       
 
       
	}

     

       
78
       
 
       


     

       
79
       
 
       
	posthog, err := posthog.NewWithConfig(config.Posthog.ApiKey, posthog.Config{Endpoint: config.Posthog.Endpoint})

     

···

       
17
       
 
       
	"github.com/urfave/cli/v3"

     

       
18
       
 
       
	"tangled.org/core/idresolver"

     

       
19
       
 
       
	"tangled.org/core/log"

     

       
0
       
 
       

     

       
20
       
 
       
)

     

       
21
       
 
       


     

       
22
       
 
       
func Command() *cli.Command {

     
···

       
57
       
 
       
func Run(ctx context.Context, cmd *cli.Command) error {

     

       
58
       
 
       
	l := log.FromContext(ctx)

     

       
59
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
60
       
 
       
	incomingUser := cmd.String("user")

     

       
61
       
 
       
	gitDir := cmd.String("git-dir")

     

       
62
       
 
       
	logPath := cmd.String("log-path")

     
···

       
122
       
 
       
	}

     

       
123
       
 
       


     

       
124
       
 
       
	didOrHandle := components[0]

     

       
125
       
-
       
	identity := resolveIdentity(ctx, l, didOrHandle)

     

       
126
       
 
       
	did := identity.DID.String()

     

       
127
       
 
       
	repoName := components[1]

     

       
128
       
 
       
	qualifiedRepoName, _ := securejoin.SecureJoin(did, repoName)

     
···

       
195
       
 
       
	return nil

     

       
196
       
 
       
}

     

       
197
       
 
       


     

       
198
       
-
       
func resolveIdentity(ctx context.Context, l *slog.Logger, didOrHandle string) *identity.Identity {

     

       
199
       
-
       
	resolver := idresolver.DefaultResolver()

     

       
200
       
 
       
	ident, err := resolver.ResolveIdent(ctx, didOrHandle)

     

       
201
       
 
       
	if err != nil {

     

       
202
       
 
       
		l.Error("Error resolving handle", "error", err, "handle", didOrHandle)

     

···

       
17
       
 
       
	"github.com/urfave/cli/v3"

     

       
18
       
 
       
	"tangled.org/core/idresolver"

     

       
19
       
 
       
	"tangled.org/core/log"

     

       
20
       
+
       
	"tangled.org/core/knotserver/config"

     

       
21
       
 
       
)

     

       
22
       
 
       


     

       
23
       
 
       
func Command() *cli.Command {

     
···

       
58
       
 
       
func Run(ctx context.Context, cmd *cli.Command) error {

     

       
59
       
 
       
	l := log.FromContext(ctx)

     

       
60
       
 
       


     

       
61
       
+
       
	c, err := config.Load(ctx)

     

       
62
       
+
       
	if err != nil {

     

       
63
       
+
       
		return fmt.Errorf("failed to load config: %w", err)

     

       
64
       
+
       
	}

     

       
65
       
+
       


     

       
66
       
 
       
	incomingUser := cmd.String("user")

     

       
67
       
 
       
	gitDir := cmd.String("git-dir")

     

       
68
       
 
       
	logPath := cmd.String("log-path")

     
···

       
128
       
 
       
	}

     

       
129
       
 
       


     

       
130
       
 
       
	didOrHandle := components[0]

     

       
131
       
+
       
	identity := resolveIdentity(ctx, c, l, didOrHandle)

     

       
132
       
 
       
	did := identity.DID.String()

     

       
133
       
 
       
	repoName := components[1]

     

       
134
       
 
       
	qualifiedRepoName, _ := securejoin.SecureJoin(did, repoName)

     
···

       
201
       
 
       
	return nil

     

       
202
       
 
       
}

     

       
203
       
 
       


     

       
204
       
+
       
func resolveIdentity(ctx context.Context, c *config.Config, l *slog.Logger, didOrHandle string) *identity.Identity {

     

       
205
       
+
       
	resolver := idresolver.DefaultResolver(c.Server.PlcUrl)

     

       
206
       
 
       
	ident, err := resolver.ResolveIdent(ctx, didOrHandle)

     

       
207
       
 
       
	if err != nil {

     

       
208
       
 
       
		l.Error("Error resolving handle", "error", err, "handle", didOrHandle)

     

···

       
17
       
 
       
	directory identity.Directory

     

       
18
       
 
       
}

     

       
19
       
 
       


     

       
20
       
-
       
func BaseDirectory() identity.Directory {

     

       
21
       
 
       
	base := identity.BaseDirectory{

     

       
22
       
-
       
		PLCURL: identity.DefaultPLCURL,

     

       
23
       
 
       
		HTTPClient: http.Client{

     

       
24
       
 
       
			Timeout: time.Second * 10,

     

       
25
       
 
       
			Transport: &http.Transport{

     
···

       
42
       
 
       
	return &base

     

       
43
       
 
       
}

     

       
44
       
 
       


     

       
45
       
-
       
func RedisDirectory(url string) (identity.Directory, error) {

     

       
46
       
 
       
	hitTTL := time.Hour * 24

     

       
47
       
 
       
	errTTL := time.Second * 30

     

       
48
       
 
       
	invalidHandleTTL := time.Minute * 5

     

       
49
       
-
       
	return redisdir.NewRedisDirectory(BaseDirectory(), url, hitTTL, errTTL, invalidHandleTTL, 10000)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
50
       
 
       
}

     

       
51
       
 
       


     

       
52
       
-
       
func DefaultResolver() *Resolver {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
53
       
 
       
	return &Resolver{

     

       
54
       
-
       
		directory: identity.DefaultDirectory(),

     

       
55
       
 
       
	}

     

       
56
       
 
       
}

     

       
57
       
 
       


     

       
58
       
-
       
func RedisResolver(redisUrl string) (*Resolver, error) {

     

       
59
       
-
       
	directory, err := RedisDirectory(redisUrl)

     

       
60
       
 
       
	if err != nil {

     

       
61
       
 
       
		return nil, err

     

       
62
       
 
       
	}

     

···

       
17
       
 
       
	directory identity.Directory

     

       
18
       
 
       
}

     

       
19
       
 
       


     

       
20
       
+
       
func BaseDirectory(plcUrl string) identity.Directory {

     

       
21
       
 
       
	base := identity.BaseDirectory{

     

       
22
       
+
       
		PLCURL: plcUrl,

     

       
23
       
 
       
		HTTPClient: http.Client{

     

       
24
       
 
       
			Timeout: time.Second * 10,

     

       
25
       
 
       
			Transport: &http.Transport{

     
···

       
42
       
 
       
	return &base

     

       
43
       
 
       
}

     

       
44
       
 
       


     

       
45
       
+
       
func RedisDirectory(url, plcUrl string) (identity.Directory, error) {

     

       
46
       
 
       
	hitTTL := time.Hour * 24

     

       
47
       
 
       
	errTTL := time.Second * 30

     

       
48
       
 
       
	invalidHandleTTL := time.Minute * 5

     

       
49
       
+
       
	return redisdir.NewRedisDirectory(

     

       
50
       
+
       
		BaseDirectory(plcUrl),

     

       
51
       
+
       
		url,

     

       
52
       
+
       
		hitTTL,

     

       
53
       
+
       
		errTTL,

     

       
54
       
+
       
		invalidHandleTTL,

     

       
55
       
+
       
		10000,

     

       
56
       
+
       
	)

     

       
57
       
 
       
}

     

       
58
       
 
       


     

       
59
       
+
       
func DefaultResolver(plcUrl string) *Resolver {

     

       
60
       
+
       
	base := BaseDirectory(plcUrl)

     

       
61
       
+
       
	cached := identity.NewCacheDirectory(base, 250_000, time.Hour*24, time.Minute*2, time.Minute*5)

     

       
62
       
 
       
	return &Resolver{

     

       
63
       
+
       
		directory: &cached,

     

       
64
       
 
       
	}

     

       
65
       
 
       
}

     

       
66
       
 
       


     

       
67
       
+
       
func RedisResolver(redisUrl, plcUrl string) (*Resolver, error) {

     

       
68
       
+
       
	directory, err := RedisDirectory(redisUrl, plcUrl)

     

       
69
       
 
       
	if err != nil {

     

       
70
       
 
       
		return nil, err

     

       
71
       
 
       
	}

     

···

       
19
       
 
       
	InternalListenAddr string `env:"INTERNAL_LISTEN_ADDR, default=127.0.0.1:5444"`

     

       
20
       
 
       
	DBPath             string `env:"DB_PATH, default=knotserver.db"`

     

       
21
       
 
       
	Hostname           string `env:"HOSTNAME, required"`

     

       
0
       
 
       

     

       
22
       
 
       
	JetstreamEndpoint  string `env:"JETSTREAM_ENDPOINT, default=wss://jetstream1.us-west.bsky.network/subscribe"`

     

       
23
       
 
       
	Owner              string `env:"OWNER, required"`

     

       
24
       
 
       
	LogDids            bool   `env:"LOG_DIDS, default=true"`

     

···

       
19
       
 
       
	InternalListenAddr string `env:"INTERNAL_LISTEN_ADDR, default=127.0.0.1:5444"`

     

       
20
       
 
       
	DBPath             string `env:"DB_PATH, default=knotserver.db"`

     

       
21
       
 
       
	Hostname           string `env:"HOSTNAME, required"`

     

       
22
       
+
       
	PlcUrl             string `env:"PLC_URL, default=plc.directory"`

     

       
23
       
 
       
	JetstreamEndpoint  string `env:"JETSTREAM_ENDPOINT, default=wss://jetstream1.us-west.bsky.network/subscribe"`

     

       
24
       
 
       
	Owner              string `env:"OWNER, required"`

     

       
25
       
 
       
	LogDids            bool   `env:"LOG_DIDS, default=true"`

     

···

       
16
       
 
       
	"github.com/bluesky-social/jetstream/pkg/models"

     

       
17
       
 
       
	securejoin "github.com/cyphar/filepath-securejoin"

     

       
18
       
 
       
	"tangled.org/core/api/tangled"

     

       
19
       
-
       
	"tangled.org/core/idresolver"

     

       
20
       
 
       
	"tangled.org/core/knotserver/db"

     

       
21
       
 
       
	"tangled.org/core/knotserver/git"

     

       
22
       
 
       
	"tangled.org/core/log"

     
···

       
120
       
 
       
	}

     

       
121
       
 
       


     

       
122
       
 
       
	// resolve this aturi to extract the repo record

     

       
123
       
-
       
	resolver := idresolver.DefaultResolver()

     

       
124
       
-
       
	ident, err := resolver.ResolveIdent(ctx, repoAt.Authority().String())

     

       
125
       
 
       
	if err != nil || ident.Handle.IsInvalidHandle() {

     

       
126
       
 
       
		return fmt.Errorf("failed to resolve handle: %w", err)

     

       
127
       
 
       
	}

     
···

       
233
       
 
       
		return err

     

       
234
       
 
       
	}

     

       
235
       
 
       


     

       
236
       
-
       
	resolver := idresolver.DefaultResolver()

     

       
237
       
-
       


     

       
238
       
-
       
	subjectId, err := resolver.ResolveIdent(ctx, record.Subject)

     

       
239
       
 
       
	if err != nil || subjectId.Handle.IsInvalidHandle() {

     

       
240
       
 
       
		return err

     

       
241
       
 
       
	}

     

       
242
       
 
       


     

       
243
       
 
       
	// TODO: fix this for good, we need to fetch the record here unfortunately

     

       
244
       
 
       
	// resolve this aturi to extract the repo record

     

       
245
       
-
       
	owner, err := resolver.ResolveIdent(ctx, repoAt.Authority().String())

     

       
246
       
 
       
	if err != nil || owner.Handle.IsInvalidHandle() {

     

       
247
       
 
       
		return fmt.Errorf("failed to resolve handle: %w", err)

     

       
248
       
 
       
	}

     

···

       
16
       
 
       
	"github.com/bluesky-social/jetstream/pkg/models"

     

       
17
       
 
       
	securejoin "github.com/cyphar/filepath-securejoin"

     

       
18
       
 
       
	"tangled.org/core/api/tangled"

     

       
0
       
 
       

     

       
19
       
 
       
	"tangled.org/core/knotserver/db"

     

       
20
       
 
       
	"tangled.org/core/knotserver/git"

     

       
21
       
 
       
	"tangled.org/core/log"

     
···

       
119
       
 
       
	}

     

       
120
       
 
       


     

       
121
       
 
       
	// resolve this aturi to extract the repo record

     

       
122
       
+
       
	ident, err := h.resolver.ResolveIdent(ctx, repoAt.Authority().String())

     

       
0
       
 
       

     

       
123
       
 
       
	if err != nil || ident.Handle.IsInvalidHandle() {

     

       
124
       
 
       
		return fmt.Errorf("failed to resolve handle: %w", err)

     

       
125
       
 
       
	}

     
···

       
231
       
 
       
		return err

     

       
232
       
 
       
	}

     

       
233
       
 
       


     

       
234
       
+
       
	subjectId, err := h.resolver.ResolveIdent(ctx, record.Subject)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
235
       
 
       
	if err != nil || subjectId.Handle.IsInvalidHandle() {

     

       
236
       
 
       
		return err

     

       
237
       
 
       
	}

     

       
238
       
 
       


     

       
239
       
 
       
	// TODO: fix this for good, we need to fetch the record here unfortunately

     

       
240
       
 
       
	// resolve this aturi to extract the repo record

     

       
241
       
+
       
	owner, err := h.resolver.ResolveIdent(ctx, repoAt.Authority().String())

     

       
242
       
 
       
	if err != nil || owner.Handle.IsInvalidHandle() {

     

       
243
       
 
       
		return fmt.Errorf("failed to resolve handle: %w", err)

     

       
244
       
 
       
	}

     

···

       
145
       
 
       


     

       
146
       
 
       
func (h *InternalHandle) replyCompare(line git.PostReceiveLine, repoOwner string, gitRelativeDir string, repoName string, ctx context.Context) ([]string, error) {

     

       
147
       
 
       
	l := h.l.With("handler", "replyCompare")

     

       
148
       
-
       
	userIdent, err := idresolver.DefaultResolver().ResolveIdent(ctx, repoOwner)

     

       
149
       
 
       
	user := repoOwner

     

       
150
       
 
       
	if err != nil {

     

       
151
       
 
       
		l.Error("Failed to fetch user identity", "err", err)

     

···

       
145
       
 
       


     

       
146
       
 
       
func (h *InternalHandle) replyCompare(line git.PostReceiveLine, repoOwner string, gitRelativeDir string, repoName string, ctx context.Context) ([]string, error) {

     

       
147
       
 
       
	l := h.l.With("handler", "replyCompare")

     

       
148
       
+
       
	userIdent, err := idresolver.DefaultResolver(h.c.Server.PlcUrl).ResolveIdent(ctx, repoOwner)

     

       
149
       
 
       
	user := repoOwner

     

       
150
       
 
       
	if err != nil {

     

       
151
       
 
       
		l.Error("Failed to fetch user identity", "err", err)

     

···

       
36
       
 
       
		l:        log.FromContext(ctx),

     

       
37
       
 
       
		jc:       jc,

     

       
38
       
 
       
		n:        n,

     

       
39
       
-
       
		resolver: idresolver.DefaultResolver(),

     

       
40
       
 
       
	}

     

       
41
       
 
       


     

       
42
       
 
       
	err := e.AddKnot(rbac.ThisServer)

     

···

       
36
       
 
       
		l:        log.FromContext(ctx),

     

       
37
       
 
       
		jc:       jc,

     

       
38
       
 
       
		n:        n,

     

       
39
       
+
       
		resolver: idresolver.DefaultResolver(c.Server.PlcUrl),

     

       
40
       
 
       
	}

     

       
41
       
 
       


     

       
42
       
 
       
	err := e.AddKnot(rbac.ThisServer)

     

···

       
13
       
 
       
	DBPath            string  `env:"DB_PATH, default=spindle.db"`

     

       
14
       
 
       
	Hostname          string  `env:"HOSTNAME, required"`

     

       
15
       
 
       
	JetstreamEndpoint string  `env:"JETSTREAM_ENDPOINT, default=wss://jetstream1.us-west.bsky.network/subscribe"`

     

       
0
       
 
       

     

       
16
       
 
       
	Dev               bool    `env:"DEV, default=false"`

     

       
17
       
 
       
	Owner             string  `env:"OWNER, required"`

     

       
18
       
 
       
	Secrets           Secrets `env:",prefix=SECRETS_"`

     

···

       
13
       
 
       
	DBPath            string  `env:"DB_PATH, default=spindle.db"`

     

       
14
       
 
       
	Hostname          string  `env:"HOSTNAME, required"`

     

       
15
       
 
       
	JetstreamEndpoint string  `env:"JETSTREAM_ENDPOINT, default=wss://jetstream1.us-west.bsky.network/subscribe"`

     

       
16
       
+
       
	PlcUrl            string `env:"PLC_URL, default=plc.directory"`

     

       
17
       
 
       
	Dev               bool    `env:"DEV, default=false"`

     

       
18
       
 
       
	Owner             string  `env:"OWNER, required"`

     

       
19
       
 
       
	Secrets           Secrets `env:",prefix=SECRETS_"`

     

···

       
9
       
 
       


     

       
10
       
 
       
	"tangled.org/core/api/tangled"

     

       
11
       
 
       
	"tangled.org/core/eventconsumer"

     

       
12
       
-
       
	"tangled.org/core/idresolver"

     

       
13
       
 
       
	"tangled.org/core/rbac"

     

       
14
       
 
       
	"tangled.org/core/spindle/db"

     

       
15
       
 
       


     
···

       
142
       
 
       
func (s *Spindle) ingestRepo(ctx context.Context, e *models.Event) error {

     

       
143
       
 
       
	var err error

     

       
144
       
 
       
	did := e.Did

     

       
145
       
-
       
	resolver := idresolver.DefaultResolver()

     

       
146
       
 
       


     

       
147
       
 
       
	l := s.l.With("component", "ingester", "record", tangled.RepoNSID)

     

       
148
       
 
       


     
···

       
190
       
 
       
		}

     

       
191
       
 
       


     

       
192
       
 
       
		// add collaborators to rbac

     

       
193
       
-
       
		owner, err := resolver.ResolveIdent(ctx, did)

     

       
194
       
 
       
		if err != nil || owner.Handle.IsInvalidHandle() {

     

       
195
       
 
       
			return err

     

       
196
       
 
       
		}

     
···

       
225
       
 
       
			return err

     

       
226
       
 
       
		}

     

       
227
       
 
       


     

       
228
       
-
       
		resolver := idresolver.DefaultResolver()

     

       
229
       
-
       


     

       
230
       
-
       
		subjectId, err := resolver.ResolveIdent(ctx, record.Subject)

     

       
231
       
 
       
		if err != nil || subjectId.Handle.IsInvalidHandle() {

     

       
232
       
 
       
			return err

     

       
233
       
 
       
		}

     
···

       
240
       
 
       


     

       
241
       
 
       
		// TODO: get rid of this entirely

     

       
242
       
 
       
		// resolve this aturi to extract the repo record

     

       
243
       
-
       
		owner, err := resolver.ResolveIdent(ctx, repoAt.Authority().String())

     

       
244
       
 
       
		if err != nil || owner.Handle.IsInvalidHandle() {

     

       
245
       
 
       
			return fmt.Errorf("failed to resolve handle: %w", err)

     

       
246
       
 
       
		}

     

···

       
9
       
 
       


     

       
10
       
 
       
	"tangled.org/core/api/tangled"

     

       
11
       
 
       
	"tangled.org/core/eventconsumer"

     

       
0
       
 
       

     

       
12
       
 
       
	"tangled.org/core/rbac"

     

       
13
       
 
       
	"tangled.org/core/spindle/db"

     

       
14
       
 
       


     
···

       
141
       
 
       
func (s *Spindle) ingestRepo(ctx context.Context, e *models.Event) error {

     

       
142
       
 
       
	var err error

     

       
143
       
 
       
	did := e.Did

     

       
0
       
 
       

     

       
144
       
 
       


     

       
145
       
 
       
	l := s.l.With("component", "ingester", "record", tangled.RepoNSID)

     

       
146
       
 
       


     
···

       
188
       
 
       
		}

     

       
189
       
 
       


     

       
190
       
 
       
		// add collaborators to rbac

     

       
191
       
+
       
		owner, err := s.res.ResolveIdent(ctx, did)

     

       
192
       
 
       
		if err != nil || owner.Handle.IsInvalidHandle() {

     

       
193
       
 
       
			return err

     

       
194
       
 
       
		}

     
···

       
223
       
 
       
			return err

     

       
224
       
 
       
		}

     

       
225
       
 
       


     

       
226
       
+
       
		subjectId, err := s.res.ResolveIdent(ctx, record.Subject)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
227
       
 
       
		if err != nil || subjectId.Handle.IsInvalidHandle() {

     

       
228
       
 
       
			return err

     

       
229
       
 
       
		}

     
···

       
236
       
 
       


     

       
237
       
 
       
		// TODO: get rid of this entirely

     

       
238
       
 
       
		// resolve this aturi to extract the repo record

     

       
239
       
+
       
		owner, err := s.res.ResolveIdent(ctx, repoAt.Authority().String())

     

       
240
       
 
       
		if err != nil || owner.Handle.IsInvalidHandle() {

     

       
241
       
 
       
			return fmt.Errorf("failed to resolve handle: %w", err)

     

       
242
       
 
       
		}

     

···

       
123
       
 
       
		jc.AddDid(d)

     

       
124
       
 
       
	}

     

       
125
       
 
       


     

       
126
       
-
       
	resolver := idresolver.DefaultResolver()

     

       
127
       
 
       


     

       
128
       
 
       
	spindle := Spindle{

     

       
129
       
 
       
		jc:    jc,

     

···

       
123
       
 
       
		jc.AddDid(d)

     

       
124
       
 
       
	}

     

       
125
       
 
       


     

       
126
       
+
       
	resolver := idresolver.DefaultResolver(cfg.Server.PlcUrl)

     

       
127
       
 
       


     

       
128
       
 
       
	spindle := Spindle{

     

       
129
       
 
       
		jc:    jc,