commit 9d3277e998fc3216807b5c9f9bd9e62860f347c9 · julien.rbrt.fr/tangled-core

+18 -31

appview/db/repos.go

···

       334
       334
        
       	return repos, nil

     

       335
       335
        
       }

     

       336
       336
        
       

     

       337
       337
       +
       // helper to get exactly one repo

     

       338
       338
       +
       func GetRepo(e Execer, filters ...filter) (*Repo, error) {

     

       339
       339
       +
       	repos, err := GetRepos(e, 0, filters...)

     

       340
       340
       +
       	if err != nil {

     

       341
       341
       +
       		return nil, err

     

       342
       342
       +
       	}

     

       343
       343
       +
       

     

       344
       344
       +
       	if repos == nil {

     

       345
       345
       +
       		return nil, sql.ErrNoRows

     

       346
       346
       +
       	}

     

       347
       347
       +
       

     

       348
       348
       +
       	if len(repos) != 1 {

     

       349
       349
       +
       		return nil, fmt.Errorf("too many rows returned")

     

       350
       350
       +
       	}

     

       351
       351
       +
       

     

       352
       352
       +
       	return &repos[0], nil

     

       353
       353
       +
       }

     

       354
       354
       +
       

     

       337
       355
        
       func CountRepos(e Execer, filters ...filter) (int64, error) {

     

       338
       356
        
       	var conditions []string

     

       339
       357
        
       	var args []any

     
···

       356
       374
        
       	}

     

       357
       375
        
       

     

       358
       376
        
       	return count, nil

     

       359
       359
       -
       }

     

       360
       360
       -
       

     

       361
       361
       -
       func GetRepo(e Execer, did, name string) (*Repo, error) {

     

       362
       362
       -
       	var repo Repo

     

       363
       363
       -
       	var description, spindle sql.NullString

     

       364
       364
       -
       

     

       365
       365
       -
       	row := e.QueryRow(`

     

       366
       366
       -
       		select did, name, knot, created, description, spindle, rkey

     

       367
       367
       -
       		from repos

     

       368
       368
       -
       		where did = ? and name = ?

     

       369
       369
       -
       		`,

     

       370
       370
       -
       		did,

     

       371
       371
       -
       		name,

     

       372
       372
       -
       	)

     

       373
       373
       -
       

     

       374
       374
       -
       	var createdAt string

     

       375
       375
       -
       	if err := row.Scan(&repo.Did, &repo.Name, &repo.Knot, &createdAt, &description, &spindle, &repo.Rkey); err != nil {

     

       376
       376
       -
       		return nil, err

     

       377
       377
       -
       	}

     

       378
       378
       -
       	createdAtTime, _ := time.Parse(time.RFC3339, createdAt)

     

       379
       379
       -
       	repo.Created = createdAtTime

     

       380
       380
       -
       

     

       381
       381
       -
       	if description.Valid {

     

       382
       382
       -
       		repo.Description = description.String

     

       383
       383
       -
       	}

     

       384
       384
       -
       

     

       385
       385
       -
       	if spindle.Valid {

     

       386
       386
       -
       		repo.Spindle = spindle.String

     

       387
       387
       -
       	}

     

       388
       388
       -
       

     

       389
       389
       -
       	return &repo, nil

     

       390
       377
        
       }

     

       391
       378
        
       

     

       392
       379
        
       func GetRepoByAtUri(e Execer, atUri string) (*Repo, error) {

+1 -1

appview/issues/router.go

···

       14
       14
        
       		r.With(middleware.Paginate).Get("/", i.RepoIssues)

     

       15
       15
        
       

     

       16
       16
        
       		r.Route("/{issue}", func(r chi.Router) {

     

       17
       17
       -
       			r.Use(mw.ResolveIssue())

     

       17
       17
       +
       			r.Use(mw.ResolveIssue)

     

       18
       18
        
       			r.Get("/", i.RepoSingleIssue)

     

       19
       19
        
       

     

       20
       20
        
       			// authenticated routes

+38 -37

appview/middleware/middleware.go

···

       213
       213
        
       				return

     

       214
       214
        
       			}

     

       215
       215
        
       

     

       216
       216
       -
       			repo, err := db.GetRepo(mw.db, id.DID.String(), repoName)

     

       216
       216
       +
       			repo, err := db.GetRepo(

     

       217
       217
       +
       				mw.db,

     

       218
       218
       +
       				db.FilterEq("did", id.DID.String()),

     

       219
       219
       +
       				db.FilterEq("name", repoName),

     

       220
       220
       +
       			)

     

       217
       221
        
       			if err != nil {

     

       218
       218
       -
       				// invalid did or handle

     

       219
       219
       -
       				log.Println("failed to resolve repo")

     

       222
       222
       +
       				log.Println("failed to resolve repo", "err", err)

     

       220
       223
        
       				mw.pages.ErrorKnot404(w)

     

       221
       224
        
       				return

     

       222
       225
        
       			}

     
···

       276
       279
        
       }

     

       277
       280
        
       

     

       278
       281
        
       // middleware that is tacked on top of /{user}/{repo}/issues/{issue}

     

       279
       279
       -
       func (mw Middleware) ResolveIssue() middlewareFunc {

     

       280
       280
       -
       	return func(next http.Handler) http.Handler {

     

       281
       281
       -
       		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

     

       282
       282
       -
       			f, err := mw.repoResolver.Resolve(r)

     

       283
       283
       -
       			if err != nil {

     

       284
       284
       -
       				log.Println("failed to fully resolve repo", err)

     

       285
       285
       -
       				mw.pages.ErrorKnot404(w)

     

       286
       286
       -
       				return

     

       287
       287
       -
       			}

     

       282
       282
       +
       func (mw Middleware) ResolveIssue(next http.Handler) http.Handler {

     

       283
       283
       +
       	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

     

       284
       284
       +
       		f, err := mw.repoResolver.Resolve(r)

     

       285
       285
       +
       		if err != nil {

     

       286
       286
       +
       			log.Println("failed to fully resolve repo", err)

     

       287
       287
       +
       			mw.pages.ErrorKnot404(w)

     

       288
       288
       +
       			return

     

       289
       289
       +
       		}

     

       288
       290
        
       

     

       289
       289
       -
       			issueIdStr := chi.URLParam(r, "issue")

     

       290
       290
       -
       			issueId, err := strconv.Atoi(issueIdStr)

     

       291
       291
       -
       			if err != nil {

     

       292
       292
       -
       				log.Println("failed to fully resolve issue ID", err)

     

       293
       293
       -
       				mw.pages.ErrorKnot404(w)

     

       294
       294
       -
       				return

     

       295
       295
       -
       			}

     

       291
       291
       +
       		issueIdStr := chi.URLParam(r, "issue")

     

       292
       292
       +
       		issueId, err := strconv.Atoi(issueIdStr)

     

       293
       293
       +
       		if err != nil {

     

       294
       294
       +
       			log.Println("failed to fully resolve issue ID", err)

     

       295
       295
       +
       			mw.pages.ErrorKnot404(w)

     

       296
       296
       +
       			return

     

       297
       297
       +
       		}

     

       296
       298
        
       

     

       297
       297
       -
       			issues, err := db.GetIssues(

     

       298
       298
       -
       				mw.db,

     

       299
       299
       -
       				db.FilterEq("repo_at", f.RepoAt()),

     

       300
       300
       -
       				db.FilterEq("issue_id", issueId),

     

       301
       301
       -
       			)

     

       302
       302
       -
       			if err != nil {

     

       303
       303
       -
       				log.Println("failed to get issues", "err", err)

     

       304
       304
       -
       				return

     

       305
       305
       -
       			}

     

       306
       306
       -
       			if len(issues) != 1 {

     

       307
       307
       -
       				log.Println("got incorrect number of issues", "len(issuse)", len(issues))

     

       308
       308
       -
       				return

     

       309
       309
       -
       			}

     

       310
       310
       -
       			issue := issues[0]

     

       299
       299
       +
       		issues, err := db.GetIssues(

     

       300
       300
       +
       			mw.db,

     

       301
       301
       +
       			db.FilterEq("repo_at", f.RepoAt()),

     

       302
       302
       +
       			db.FilterEq("issue_id", issueId),

     

       303
       303
       +
       		)

     

       304
       304
       +
       		if err != nil {

     

       305
       305
       +
       			log.Println("failed to get issues", "err", err)

     

       306
       306
       +
       			return

     

       307
       307
       +
       		}

     

       308
       308
       +
       		if len(issues) != 1 {

     

       309
       309
       +
       			log.Println("got incorrect number of issues", "len(issuse)", len(issues))

     

       310
       310
       +
       			return

     

       311
       311
       +
       		}

     

       312
       312
       +
       		issue := issues[0]

     

       311
       313
        
       

     

       312
       312
       -
       			ctx := context.WithValue(r.Context(), "issue", &issue)

     

       313
       313
       -
       			next.ServeHTTP(w, r.WithContext(ctx))

     

       314
       314
       -
       		})

     

       315
       315
       -
       	}

     

       314
       314
       +
       		ctx := context.WithValue(r.Context(), "issue", &issue)

     

       315
       315
       +
       		next.ServeHTTP(w, r.WithContext(ctx))

     

       316
       316
       +
       	})

     

       316
       317
        
       }

     

       317
       318
        
       

     

       318
       319
        
       // this should serve the go-import meta tag even if the path is technically

+6 -2

appview/pulls/pulls.go

···

       1364
       1364
        
       	forkOwnerDid := repoString[0]

     

       1365
       1365
        
       	forkName := repoString[1]

     

       1366
       1366
        
       	// fork repo

     

       1367
       1367
       -
       	repo, err := db.GetRepo(s.db, forkOwnerDid, forkName)

     

       1367
       1367
       +
       	repo, err := db.GetRepo(

     

       1368
       1368
       +
       		s.db,

     

       1369
       1369
       +
       		db.FilterEq("did", forkOwnerDid),

     

       1370
       1370
       +
       		db.FilterEq("name", forkName),

     

       1371
       1371
       +
       	)

     

       1368
       1372
        
       	if err != nil {

     

       1369
       1369
       -
       		log.Println("failed to get repo", user.Did, forkVal)

     

       1373
       1373
       +
       		log.Println("failed to get repo", "did", forkOwnerDid, "name", forkName, "err", err)

     

       1370
       1374
        
       		return

     

       1371
       1375
        
       	}

     

       1372
       1376

+5 -1

appview/repo/repo.go

···

       1580
       1580
        
       		forkName := f.Name

     

       1581
       1581
        
       		// this check is *only* to see if the forked repo name already exists

     

       1582
       1582
        
       		// in the user's account.

     

       1583
       1583
       -
       		existingRepo, err := db.GetRepo(rp.db, user.Did, f.Name)

     

       1583
       1583
       +
       		existingRepo, err := db.GetRepo(

     

       1584
       1584
       +
       			rp.db,

     

       1585
       1585
       +
       			db.FilterEq("did", user.Did),

     

       1586
       1586
       +
       			db.FilterEq("name", f.Name),

     

       1587
       1587
       +
       		)

     

       1584
       1588
        
       		if err != nil {

     

       1585
       1589
        
       			if errors.Is(err, sql.ErrNoRows) {

     

       1586
       1590
        
       				// no existing repo with this name found, we can use the name as is

+5 -1

appview/state/state.go

···

       419
       419
        
       		}

     

       420
       420
        
       

     

       421
       421
        
       		// Check for existing repos

     

       422
       422
       -
       		existingRepo, err := db.GetRepo(s.db, user.Did, repoName)

     

       422
       422
       +
       		existingRepo, err := db.GetRepo(

     

       423
       423
       +
       			s.db,

     

       424
       424
       +
       			db.FilterEq("did", user.Did),

     

       425
       425
       +
       			db.FilterEq("name", repoName),

     

       426
       426
       +
       		)

     

       423
       427
        
       		if err == nil && existingRepo != nil {

     

       424
       428
        
       			l.Info("repo exists")

     

       425
       429
        
       			s.pages.Notice(w, "repo", fmt.Sprintf("You already have a repository by this name on %s", existingRepo.Knot))

+1 -1

spindle/ingester.go

···

       146
       146
        
       

     

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

     

       148
       148
        
       

     

       149
       149
       -
       	l.Info("ingesting repo record")

     

       149
       149
       +
       	l.Info("ingesting repo record", "did", did)

     

       150
       150
        
       

     

       151
       151
        
       	switch e.Commit.Operation {

     

       152
       152
        
       	case models.CommitOperationCreate, models.CommitOperationUpdate: