appview/consts: init consts package

things like TangledDid are now defined in the consts package

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

appview/db/label.go

···
 
 	"github.com/bluesky-social/indigo/atproto/syntax"
 	"tangled.sh/tangled.sh/core/api/tangled"
+	"tangled.sh/tangled.sh/core/consts"
 )
 
 type ConcreteType string
···
 	return vt.Type == ConcreteTypeBool
 }
 
-func (vt ValueType) IsEnumType() bool {
+func (vt ValueType) IsEnum() bool {
 	return len(vt.Enum) > 0
 }
 
···
 
 	Name      string
 	ValueType ValueType
-	Scope     syntax.NSID
+	Scope     []string
 	Color     *string
 	Multiple  bool
 	Created   time.Time
···
 		Color:     l.Color,
 		CreatedAt: l.Created.Format(time.RFC3339),
 		Multiple:  &l.Multiple,
-		Scope:     l.Scope.String(),
+		Scope:     l.Scope,
 		ValueType: &vt,
 	}
 }
···
 	return *ld.Color
 }
 
-func LabelDefinitionFromRecord(did, rkey string, record tangled.LabelDefinition) LabelDefinition {
+func LabelDefinitionFromRecord(did, rkey string, record tangled.LabelDefinition) (*LabelDefinition, error) {
 	created, err := time.Parse(time.RFC3339, record.CreatedAt)
 	if err != nil {
 		created = time.Now()
···
 		vt = ValueTypeFromRecord(*record.ValueType)
 	}
 
-	return LabelDefinition{
+	return &LabelDefinition{
 		Did:  did,
 		Rkey: rkey,
 
 		Name:      record.Name,
 		ValueType: vt,
-		Scope:     syntax.NSID(record.Scope),
+		Scope:     record.Scope,
 		Color:     record.Color,
 		Multiple:  multiple,
 		Created:   created,
-	}
+	}, nil
 }
 
 func DeleteLabelDefinition(e Execer, filters ...filter) error {
···
 	return err
 }
 
+// no updating type for now
 func AddLabelDefinition(e Execer, l *LabelDefinition) (int64, error) {
 	result, err := e.Exec(
 		`insert into label_definitions (
···
 		l.ValueType.Type,
 		l.ValueType.Format,
 		strings.Join(l.ValueType.Enum, ","),
-		l.Scope.String(),
+		strings.Join(l.Scope, ","),
 		l.Color,
 		l.Multiple,
 		l.Created.Format(time.RFC3339),
···
 
 	for rows.Next() {
 		var labelDefinition LabelDefinition
-		var createdAt, enumVariants string
+		var createdAt, enumVariants, scopes string
 		var color sql.Null[string]
 		var multiple int
 
···
 			&labelDefinition.ValueType.Type,
 			&labelDefinition.ValueType.Format,
 			&enumVariants,
-			&labelDefinition.Scope,
+			&scopes,
 			&color,
 			&multiple,
 			&createdAt,
···
 
 		if enumVariants != "" {
 			labelDefinition.ValueType.Enum = strings.Split(enumVariants, ",")
+		}
+
+		for s := range strings.SplitSeq(scopes, ",") {
+			labelDefinition.Scope = append(labelDefinition.Scope, s)
 		}
 
 		labelDefinitions = append(labelDefinitions, labelDefinition)
···
 	return false
 }
 
-func (s *LabelState) GetValSet(l string) set {
-	return s.inner[l]
+// go maps behavior in templates make this necessary,
+// indexing a map and getting `set` in return is apparently truthy
+func (s LabelState) ContainsLabelAndVal(l, v string) bool {
+	if valset, exists := s.inner[l]; exists {
+		if _, exists := valset[v]; exists {
+			return true
+		}
+	}
+
+	return false
+}
+
+func (s LabelState) GetValSet(l string) set {
+	if valset, exists := s.inner[l]; exists {
+		return valset
+	} else {
+		return make(set)
+	}
 }
 
 type LabelApplicationCtx struct {
···
 }
 
 func (c *LabelApplicationCtx) ApplyLabelOp(state LabelState, op LabelOp) error {
-	def := c.Defs[op.OperandKey]
+	def, ok := c.Defs[op.OperandKey]
+	if !ok {
+		// this def was deleted, but an op exists, so we just skip over the op
+		return nil
+	}
 
 	switch op.Operation {
 	case LabelOperationAdd:
···
 		_ = c.ApplyLabelOp(state, o)
 	}
 }
+
+// IsInverse checks if one label operation is the inverse of another
+// returns true if one is an add and the other is a delete with the same key and value
+func (op1 LabelOp) IsInverse(op2 LabelOp) bool {
+	if op1.OperandKey != op2.OperandKey || op1.OperandValue != op2.OperandValue {
+		return false
+	}
+
+	return (op1.Operation == LabelOperationAdd && op2.Operation == LabelOperationDel) ||
+		(op1.Operation == LabelOperationDel && op2.Operation == LabelOperationAdd)
+}
+
+// removes pairs of label operations that are inverses of each other
+// from the given slice. the function preserves the order of remaining operations.
+func ReduceLabelOps(ops []LabelOp) []LabelOp {
+	if len(ops) <= 1 {
+		return ops
+	}
+
+	keep := make([]bool, len(ops))
+	for i := range keep {
+		keep[i] = true
+	}
+
+	for i := range ops {
+		if !keep[i] {
+			continue
+		}
+
+		for j := i + 1; j < len(ops); j++ {
+			if !keep[j] {
+				continue
+			}
+
+			if ops[i].IsInverse(ops[j]) {
+				keep[i] = false
+				keep[j] = false
+				break // move to next i since this one is now eliminated
+			}
+		}
+	}
+
+	// build result slice with only kept operations
+	var result []LabelOp
+	for i, op := range ops {
+		if keep[i] {
+			result = append(result, op)
+		}
+	}
+
+	return result
+}
+
+func DefaultLabelDefs() []string {
+	rkeys := []string{
+		"wontfix",
+		"duplicate",
+		"assignee",
+		"good-first-issue",
+		"documentation",
+	}
+
+	defs := make([]string, len(rkeys))
+	for i, r := range rkeys {
+		defs[i] = fmt.Sprintf("at://%s/%s/%s", consts.TangledDid, tangled.LabelDefinitionNSID, r)
+	}
+
+	return defs
+}

appview/oauth/handler/handler.go

···
 	return pubKey, nil
 }
 
-var (
-	tangledDid = "did:plc:wshs7t2adsemcrrd4snkeqli"
-	icyDid     = "did:plc:hwevmowznbiukdf6uk5dwrrq"
-
-	defaultSpindle = "spindle.tangled.sh"
-	defaultKnot    = "knot1.tangled.sh"
-)
-
 func (o *OAuthHandler) addToDefaultSpindle(did string) {
 	// use the tangled.sh app password to get an accessJwt
 	// and create an sh.tangled.spindle.member record with that
···
 	}
 
 	log.Printf("adding %s to default spindle", did)
-	session, err := o.createAppPasswordSession(o.config.Core.AppPassword, tangledDid)
+	session, err := o.createAppPasswordSession(o.config.Core.AppPassword, consts.TangledDid)
 	if err != nil {
 		log.Printf("failed to create session: %s", err)
 		return
···
 	record := tangled.SpindleMember{
 		LexiconTypeID: "sh.tangled.spindle.member",
 		Subject:       did,
-		Instance:      defaultSpindle,
+		Instance:      consts.DefaultSpindle,
 		CreatedAt:     time.Now().Format(time.RFC3339),
 	}
 
···
 		return
 	}
 
-	if slices.Contains(allKnots, defaultKnot) {
+	if slices.Contains(allKnots, consts.DefaultKnot) {
 		log.Printf("did %s is already a member of the default knot", did)
 		return
 	}
 
 	log.Printf("adding %s to default knot", did)
-	session, err := o.createAppPasswordSession(o.config.Core.TmpAltAppPassword, icyDid)
+	session, err := o.createAppPasswordSession(o.config.Core.TmpAltAppPassword, consts.IcyDid)
 	if err != nil {
 		log.Printf("failed to create session: %s", err)
 		return
···
 	record := tangled.KnotMember{
 		LexiconTypeID: "sh.tangled.knot.member",
 		Subject:       did,
-		Domain:        defaultKnot,
+		Domain:        consts.DefaultKnot,
 		CreatedAt:     time.Now().Format(time.RFC3339),
 	}
 
···
 		return
 	}
 
-	if err := o.enforcer.AddKnotMember(defaultKnot, did); err != nil {
+	if err := o.enforcer.AddKnotMember(consts.DefaultKnot, did); err != nil {
 		log.Printf("failed to set up enforcer rules: %s", err)
 		return
 	}