appview/models: init

move db.Artifact to models.Artifact

Signed-off-by: oppiliappan <[e-mail]>

appview/db/artifact.go

···
 	"strings"
 	"time"
 
-	"github.com/bluesky-social/indigo/atproto/syntax"
 	"github.com/go-git/go-git/v5/plumbing"
 	"github.com/ipfs/go-cid"
-	"tangled.org/core/api/tangled"
+	"tangled.org/core/appview/models"
 )
 
-type Artifact struct {
-	Id   uint64
-	Did  string
-	Rkey string
-
-	RepoAt    syntax.ATURI
-	Tag       plumbing.Hash
-	CreatedAt time.Time
-
-	BlobCid  cid.Cid
-	Name     string
-	Size     uint64
-	MimeType string
-}
-
-func (a *Artifact) ArtifactAt() syntax.ATURI {
-	return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", a.Did, tangled.RepoArtifactNSID, a.Rkey))
-}
-
-func AddArtifact(e Execer, artifact Artifact) error {
+func AddArtifact(e Execer, artifact models.Artifact) error {
 	_, err := e.Exec(
 		`insert or ignore into artifacts (
 			did,
···
 	return err
 }
 
-func GetArtifact(e Execer, filters ...filter) ([]Artifact, error) {
-	var artifacts []Artifact
+func GetArtifact(e Execer, filters ...filter) ([]models.Artifact, error) {
+	var artifacts []models.Artifact
 
 	var conditions []string
 	var args []any
···
 	defer rows.Close()
 
 	for rows.Next() {
-		var artifact Artifact
+		var artifact models.Artifact
 		var createdAt string
 		var tag []byte
 		var blobCid string

appview/ingester.go

···
 	"time"
 
 	"github.com/bluesky-social/indigo/atproto/syntax"
-	"github.com/bluesky-social/jetstream/pkg/models"
+	jmodels "github.com/bluesky-social/jetstream/pkg/models"
 	"github.com/go-git/go-git/v5/plumbing"
 	"github.com/ipfs/go-cid"
 	"tangled.org/core/api/tangled"
 	"tangled.org/core/appview/config"
 	"tangled.org/core/appview/db"
+	"tangled.org/core/appview/models"
 	"tangled.org/core/appview/serververify"
 	"tangled.org/core/appview/validator"
 	"tangled.org/core/idresolver"
···
 	Validator  *validator.Validator
 }
 
-type processFunc func(ctx context.Context, e *models.Event) error
+type processFunc func(ctx context.Context, e *jmodels.Event) error
 
 func (i *Ingester) Ingest() processFunc {
-	return func(ctx context.Context, e *models.Event) error {
+	return func(ctx context.Context, e *jmodels.Event) error {
 		var err error
 		defer func() {
 			eventTime := e.TimeUS
···
 
 		l := i.Logger.With("kind", e.Kind)
 		switch e.Kind {
-		case models.EventKindAccount:
+		case jmodels.EventKindAccount:
 			if !e.Account.Active && *e.Account.Status == "deactivated" {
 				err = i.IdResolver.InvalidateIdent(ctx, e.Account.Did)
 			}
-		case models.EventKindIdentity:
+		case jmodels.EventKindIdentity:
 			err = i.IdResolver.InvalidateIdent(ctx, e.Identity.Did)
-		case models.EventKindCommit:
+		case jmodels.EventKindCommit:
 			switch e.Commit.Collection {
 			case tangled.GraphFollowNSID:
 				err = i.ingestFollow(e)
···
 	}
 }
 
-func (i *Ingester) ingestStar(e *models.Event) error {
+func (i *Ingester) ingestStar(e *jmodels.Event) error {
 	var err error
 	did := e.Did
 
···
 	l = l.With("nsid", e.Commit.Collection)
 
 	switch e.Commit.Operation {
-	case models.CommitOperationCreate, models.CommitOperationUpdate:
+	case jmodels.CommitOperationCreate, jmodels.CommitOperationUpdate:
 		var subjectUri syntax.ATURI
 
 		raw := json.RawMessage(e.Commit.Record)
···
 			RepoAt:       subjectUri,
 			Rkey:         e.Commit.RKey,
 		})
-	case models.CommitOperationDelete:
+	case jmodels.CommitOperationDelete:
 		err = db.DeleteStarByRkey(i.Db, did, e.Commit.RKey)
 	}
 
···
 	return nil
 }
 
-func (i *Ingester) ingestFollow(e *models.Event) error {
+func (i *Ingester) ingestFollow(e *jmodels.Event) error {
 	var err error
 	did := e.Did
 
···
 	l = l.With("nsid", e.Commit.Collection)
 
 	switch e.Commit.Operation {
-	case models.CommitOperationCreate, models.CommitOperationUpdate:
+	case jmodels.CommitOperationCreate, jmodels.CommitOperationUpdate:
 		raw := json.RawMessage(e.Commit.Record)
 		record := tangled.GraphFollow{}
 		err = json.Unmarshal(raw, &record)
···
 			SubjectDid: record.Subject,
 			Rkey:       e.Commit.RKey,
 		})
-	case models.CommitOperationDelete:
+	case jmodels.CommitOperationDelete:
 		err = db.DeleteFollowByRkey(i.Db, did, e.Commit.RKey)
 	}
 
···
 	return nil
 }
 
-func (i *Ingester) ingestPublicKey(e *models.Event) error {
+func (i *Ingester) ingestPublicKey(e *jmodels.Event) error {
 	did := e.Did
 	var err error
 
···
 	l = l.With("nsid", e.Commit.Collection)
 
 	switch e.Commit.Operation {
-	case models.CommitOperationCreate, models.CommitOperationUpdate:
+	case jmodels.CommitOperationCreate, jmodels.CommitOperationUpdate:
 		l.Debug("processing add of pubkey")
 		raw := json.RawMessage(e.Commit.Record)
 		record := tangled.PublicKey{}
···
 		name := record.Name
 		key := record.Key
 		err = db.AddPublicKey(i.Db, did, name, key, e.Commit.RKey)
-	case models.CommitOperationDelete:
+	case jmodels.CommitOperationDelete:
 		l.Debug("processing delete of pubkey")
 		err = db.DeletePublicKeyByRkey(i.Db, did, e.Commit.RKey)
 	}
···
 	return nil
 }
 
-func (i *Ingester) ingestArtifact(e *models.Event) error {
+func (i *Ingester) ingestArtifact(e *jmodels.Event) error {
 	did := e.Did
 	var err error
 
···
 	l = l.With("nsid", e.Commit.Collection)
 
 	switch e.Commit.Operation {
-	case models.CommitOperationCreate, models.CommitOperationUpdate:
+	case jmodels.CommitOperationCreate, jmodels.CommitOperationUpdate:
 		raw := json.RawMessage(e.Commit.Record)
 		record := tangled.RepoArtifact{}
 		err = json.Unmarshal(raw, &record)
···
 			createdAt = time.Now()
 		}
 
-		artifact := db.Artifact{
+		artifact := models.Artifact{
 			Did:       did,
 			Rkey:      e.Commit.RKey,
 			RepoAt:    repoAt,
···
 		}
 
 		err = db.AddArtifact(i.Db, artifact)
-	case models.CommitOperationDelete:
+	case jmodels.CommitOperationDelete:
 		err = db.DeleteArtifact(i.Db, db.FilterEq("did", did), db.FilterEq("rkey", e.Commit.RKey))
 	}
 
···
 	return nil
 }
 
-func (i *Ingester) ingestProfile(e *models.Event) error {
+func (i *Ingester) ingestProfile(e *jmodels.Event) error {
 	did := e.Did
 	var err error
 
···
 	}
 
 	switch e.Commit.Operation {
-	case models.CommitOperationCreate, models.CommitOperationUpdate:
+	case jmodels.CommitOperationCreate, jmodels.CommitOperationUpdate:
 		raw := json.RawMessage(e.Commit.Record)
 		record := tangled.ActorProfile{}
 		err = json.Unmarshal(raw, &record)
···
 		}
 
 		err = db.UpsertProfile(tx, &profile)
-	case models.CommitOperationDelete:
+	case jmodels.CommitOperationDelete:
 		err = db.DeleteArtifact(i.Db, db.FilterEq("did", did), db.FilterEq("rkey", e.Commit.RKey))
 	}
 
···
 	return nil
 }
 
-func (i *Ingester) ingestSpindleMember(ctx context.Context, e *models.Event) error {
+func (i *Ingester) ingestSpindleMember(ctx context.Context, e *jmodels.Event) error {
 	did := e.Did
 	var err error
 
···
 	l = l.With("nsid", e.Commit.Collection)
 
 	switch e.Commit.Operation {
-	case models.CommitOperationCreate:
+	case jmodels.CommitOperationCreate:
 		raw := json.RawMessage(e.Commit.Record)
 		record := tangled.SpindleMember{}
 		err = json.Unmarshal(raw, &record)
···
 		}
 
 		l.Info("added spindle member")
-	case models.CommitOperationDelete:
+	case jmodels.CommitOperationDelete:
 		rkey := e.Commit.RKey
 
 		ddb, ok := i.Db.Execer.(*db.DB)
···
 	return nil
 }
 
-func (i *Ingester) ingestSpindle(ctx context.Context, e *models.Event) error {
+func (i *Ingester) ingestSpindle(ctx context.Context, e *jmodels.Event) error {
 	did := e.Did
 	var err error
 
···
 	l = l.With("nsid", e.Commit.Collection)
 
 	switch e.Commit.Operation {
-	case models.CommitOperationCreate:
+	case jmodels.CommitOperationCreate:
 		raw := json.RawMessage(e.Commit.Record)
 		record := tangled.Spindle{}
 		err = json.Unmarshal(raw, &record)
···
 
 		return nil
 
-	case models.CommitOperationDelete:
+	case jmodels.CommitOperationDelete:
 		instance := e.Commit.RKey
 
 		ddb, ok := i.Db.Execer.(*db.DB)
···
 	return nil
 }
 
-func (i *Ingester) ingestString(e *models.Event) error {
+func (i *Ingester) ingestString(e *jmodels.Event) error {
 	did := e.Did
 	rkey := e.Commit.RKey
 
···
 	}
 
 	switch e.Commit.Operation {
-	case models.CommitOperationCreate, models.CommitOperationUpdate:
+	case jmodels.CommitOperationCreate, jmodels.CommitOperationUpdate:
 		raw := json.RawMessage(e.Commit.Record)
 		record := tangled.String{}
 		err = json.Unmarshal(raw, &record)
···
 
 		return nil
 
-	case models.CommitOperationDelete:
+	case jmodels.CommitOperationDelete:
 		if err := db.DeleteString(
 			ddb,
 			db.FilterEq("did", did),
···
 	return nil
 }
 
-func (i *Ingester) ingestKnotMember(e *models.Event) error {
+func (i *Ingester) ingestKnotMember(e *jmodels.Event) error {
 	did := e.Did
 	var err error
 
···
 	l = l.With("nsid", e.Commit.Collection)
 
 	switch e.Commit.Operation {
-	case models.CommitOperationCreate:
+	case jmodels.CommitOperationCreate:
 		raw := json.RawMessage(e.Commit.Record)
 		record := tangled.KnotMember{}
 		err = json.Unmarshal(raw, &record)
···
 		}
 
 		l.Info("added knot member")
-	case models.CommitOperationDelete:
+	case jmodels.CommitOperationDelete:
 		// we don't store knot members in a table (like we do for spindle)
 		// and we can't remove this just yet. possibly fixed if we switch
 		// to either:
···
 	return nil
 }
 
-func (i *Ingester) ingestKnot(e *models.Event) error {
+func (i *Ingester) ingestKnot(e *jmodels.Event) error {
 	did := e.Did
 	var err error
 
···
 	l = l.With("nsid", e.Commit.Collection)
 
 	switch e.Commit.Operation {
-	case models.CommitOperationCreate:
+	case jmodels.CommitOperationCreate:
 		raw := json.RawMessage(e.Commit.Record)
 		record := tangled.Knot{}
 		err = json.Unmarshal(raw, &record)
···
 
 		return nil
 
-	case models.CommitOperationDelete:
+	case jmodels.CommitOperationDelete:
 		domain := e.Commit.RKey
 
 		ddb, ok := i.Db.Execer.(*db.DB)
···
 
 	return nil
 }
-func (i *Ingester) ingestIssue(ctx context.Context, e *models.Event) error {
+func (i *Ingester) ingestIssue(ctx context.Context, e *jmodels.Event) error {
 	did := e.Did
 	rkey := e.Commit.RKey
 
···
 	}
 
 	switch e.Commit.Operation {
-	case models.CommitOperationCreate, models.CommitOperationUpdate:
+	case jmodels.CommitOperationCreate, jmodels.CommitOperationUpdate:
 		raw := json.RawMessage(e.Commit.Record)
 		record := tangled.RepoIssue{}
 		err = json.Unmarshal(raw, &record)
···
 
 		return nil
 
-	case models.CommitOperationDelete:
+	case jmodels.CommitOperationDelete:
 		if err := db.DeleteIssues(
 			ddb,
 			db.FilterEq("did", did),
···
 	return nil
 }
 
-func (i *Ingester) ingestIssueComment(e *models.Event) error {
+func (i *Ingester) ingestIssueComment(e *jmodels.Event) error {
 	did := e.Did
 	rkey := e.Commit.RKey
 
···
 	}
 
 	switch e.Commit.Operation {
-	case models.CommitOperationCreate, models.CommitOperationUpdate:
+	case jmodels.CommitOperationCreate, jmodels.CommitOperationUpdate:
 		raw := json.RawMessage(e.Commit.Record)
 		record := tangled.RepoIssueComment{}
 		err = json.Unmarshal(raw, &record)
···
 
 		return nil
 
-	case models.CommitOperationDelete:
+	case jmodels.CommitOperationDelete:
 		if err := db.DeleteIssueComments(
 			ddb,
 			db.FilterEq("did", did),
···
 	return nil
 }
 
-func (i *Ingester) ingestLabelDefinition(e *models.Event) error {
+func (i *Ingester) ingestLabelDefinition(e *jmodels.Event) error {
 	did := e.Did
 	rkey := e.Commit.RKey
 
···
 	}
 
 	switch e.Commit.Operation {
-	case models.CommitOperationCreate, models.CommitOperationUpdate:
+	case jmodels.CommitOperationCreate, jmodels.CommitOperationUpdate:
 		raw := json.RawMessage(e.Commit.Record)
 		record := tangled.LabelDefinition{}
 		err = json.Unmarshal(raw, &record)
···
 
 		return nil
 
-	case models.CommitOperationDelete:
+	case jmodels.CommitOperationDelete:
 		if err := db.DeleteLabelDefinition(
 			ddb,
 			db.FilterEq("did", did),

appview/models/artifact.go

···
+package models
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/bluesky-social/indigo/atproto/syntax"
+	"github.com/go-git/go-git/v5/plumbing"
+	"github.com/ipfs/go-cid"
+	"tangled.org/core/api/tangled"
+)
+
+type Artifact struct {
+	Id   uint64
+	Did  string
+	Rkey string
+
+	RepoAt    syntax.ATURI
+	Tag       plumbing.Hash
+	CreatedAt time.Time
+
+	BlobCid  cid.Cid
+	Name     string
+	Size     uint64
+	MimeType string
+}
+
+func (a *Artifact) ArtifactAt() syntax.ATURI {
+	return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", a.Did, tangled.RepoArtifactNSID, a.Rkey))
+}

appview/pages/pages.go

···
 	"tangled.org/core/appview/commitverify"
 	"tangled.org/core/appview/config"
 	"tangled.org/core/appview/db"
+	"tangled.org/core/appview/models"
 	"tangled.org/core/appview/oauth"
 	"tangled.org/core/appview/pages/markup"
 	"tangled.org/core/appview/pages/repoinfo"
···
 	RepoInfo     repoinfo.RepoInfo
 	Active       string
 	types.RepoTagsResponse
-	ArtifactMap       map[plumbing.Hash][]db.Artifact
-	DanglingArtifacts []db.Artifact
+	ArtifactMap       map[plumbing.Hash][]models.Artifact
+	DanglingArtifacts []models.Artifact
 }
 
 func (p *Pages) RepoTags(w io.Writer, params RepoTagsParams) error {
···
 type RepoArtifactParams struct {
 	LoggedInUser *oauth.User
 	RepoInfo     repoinfo.RepoInfo
-	Artifact     db.Artifact
+	Artifact     models.Artifact
 }
 
 func (p *Pages) RepoArtifactFragment(w io.Writer, params RepoArtifactParams) error {

appview/repo/artifact.go

···
 	"github.com/ipfs/go-cid"
 	"tangled.org/core/api/tangled"
 	"tangled.org/core/appview/db"
+	"tangled.org/core/appview/models"
 	"tangled.org/core/appview/pages"
 	"tangled.org/core/appview/reporesolver"
 	"tangled.org/core/appview/xrpcclient"
···
 	}
 	defer tx.Rollback()
 
-	artifact := db.Artifact{
+	artifact := models.Artifact{
 		Did:       user.Did,
 		Rkey:      rkey,
 		RepoAt:    f.RepoAt(),

appview/repo/repo.go

···
 	"tangled.org/core/appview/commitverify"
 	"tangled.org/core/appview/config"
 	"tangled.org/core/appview/db"
+	"tangled.org/core/appview/models"
 	"tangled.org/core/appview/notify"
 	"tangled.org/core/appview/oauth"
 	"tangled.org/core/appview/pages"
···
 	}
 
 	// convert artifacts to map for easy UI building
-	artifactMap := make(map[plumbing.Hash][]db.Artifact)
+	artifactMap := make(map[plumbing.Hash][]models.Artifact)
 	for _, a := range artifacts {
 		artifactMap[a.Tag] = append(artifactMap[a.Tag], a)
 	}
 
-	var danglingArtifacts []db.Artifact
+	var danglingArtifacts []models.Artifact
 	for _, a := range artifacts {
 		found := false
 		for _, t := range result.Tags {