lexicons,appview/pulls: replace `patch` with `patchBlob`

legacy field name `patch` is preserved (but not used) to support some
level of backward compatibility

Signed-off-by: Seongmin Lee <[e-mail]>

api/tangled/cbor_gen.go

···
 	}
 
 	cw := cbg.NewCborWriter(w)
-	fieldCount := 9
+	fieldCount := 10
 
 	if t.Body == nil {
 		fieldCount--
 	}
 
 	if t.Mentions == nil {
+		fieldCount--
+	}
+
+	if t.Patch == nil {
 		fieldCount--
 	}
 
···
 	}
 
 	// t.Patch (string) (string)
-	if len("patch") > 1000000 {
-		return xerrors.Errorf("Value in field \"patch\" was too long")
-	}
+	if t.Patch != nil {
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("patch"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("patch")); err != nil {
-		return err
-	}
+		if len("patch") > 1000000 {
+			return xerrors.Errorf("Value in field \"patch\" was too long")
+		}
 
-	if len(t.Patch) > 1000000 {
-		return xerrors.Errorf("Value in field t.Patch was too long")
-	}
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("patch"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("patch")); err != nil {
+			return err
+		}
+
+		if t.Patch == nil {
+			if _, err := cw.Write(cbg.CborNull); err != nil {
+				return err
+			}
+		} else {
+			if len(*t.Patch) > 1000000 {
+				return xerrors.Errorf("Value in field t.Patch was too long")
+			}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Patch))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string(t.Patch)); err != nil {
-		return err
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Patch))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(*t.Patch)); err != nil {
+				return err
+			}
+		}
 	}
 
 	// t.Title (string) (string)
···
 		return err
 	}
 
+	// t.PatchBlob (util.LexBlob) (struct)
+	if len("patchBlob") > 1000000 {
+		return xerrors.Errorf("Value in field \"patchBlob\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("patchBlob"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("patchBlob")); err != nil {
+		return err
+	}
+
+	if err := t.PatchBlob.MarshalCBOR(cw); err != nil {
+		return err
+	}
+
 	// t.References ([]string) (slice)
 	if t.References != nil {
 
···
 		case "patch":
 
 			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				b, err := cr.ReadByte()
 				if err != nil {
 					return err
 				}
+				if b != cbg.CborNull[0] {
+					if err := cr.UnreadByte(); err != nil {
+						return err
+					}
 
-				t.Patch = string(sval)
+					sval, err := cbg.ReadStringWithMax(cr, 1000000)
+					if err != nil {
+						return err
+					}
+
+					t.Patch = (*string)(&sval)
+				}
 			}
 			// t.Title (string) (string)
 		case "title":
···
 				}
 
 				t.CreatedAt = string(sval)
+			}
+			// t.PatchBlob (util.LexBlob) (struct)
+		case "patchBlob":
+
+			{
+
+				b, err := cr.ReadByte()
+				if err != nil {
+					return err
+				}
+				if b != cbg.CborNull[0] {
+					if err := cr.UnreadByte(); err != nil {
+						return err
+					}
+					t.PatchBlob = new(util.LexBlob)
+					if err := t.PatchBlob.UnmarshalCBOR(cr); err != nil {
+						return xerrors.Errorf("unmarshaling t.PatchBlob pointer: %w", err)
+					}
+				}
+
 			}
 			// t.References ([]string) (slice)
 		case "references":

api/tangled/repopull.go

···
 } //
 // RECORDTYPE: RepoPull
 type RepoPull struct {
-	LexiconTypeID string           `json:"$type,const=sh.tangled.repo.pull" cborgen:"$type,const=sh.tangled.repo.pull"`
-	Body          *string          `json:"body,omitempty" cborgen:"body,omitempty"`
-	CreatedAt     string           `json:"createdAt" cborgen:"createdAt"`
-	Mentions      []string         `json:"mentions,omitempty" cborgen:"mentions,omitempty"`
-	Patch         string           `json:"patch" cborgen:"patch"`
-	References    []string         `json:"references,omitempty" cborgen:"references,omitempty"`
-	Source        *RepoPull_Source `json:"source,omitempty" cborgen:"source,omitempty"`
-	Target        *RepoPull_Target `json:"target" cborgen:"target"`
-	Title         string           `json:"title" cborgen:"title"`
+	LexiconTypeID string   `json:"$type,const=sh.tangled.repo.pull" cborgen:"$type,const=sh.tangled.repo.pull"`
+	Body          *string  `json:"body,omitempty" cborgen:"body,omitempty"`
+	CreatedAt     string   `json:"createdAt" cborgen:"createdAt"`
+	Mentions      []string `json:"mentions,omitempty" cborgen:"mentions,omitempty"`
+	// patch: (deprecated) use patchBlob instead
+	Patch *string `json:"patch,omitempty" cborgen:"patch,omitempty"`
+	// patchBlob: patch content
+	PatchBlob  *util.LexBlob    `json:"patchBlob" cborgen:"patchBlob"`
+	References []string         `json:"references,omitempty" cborgen:"references,omitempty"`
+	Source     *RepoPull_Source `json:"source,omitempty" cborgen:"source,omitempty"`
+	Target     *RepoPull_Target `json:"target" cborgen:"target"`
+	Title      string           `json:"title" cborgen:"title"`
 }
 
 // RepoPull_Source is a "source" in the sh.tangled.repo.pull schema.

appview/pulls/pulls.go

···
 					Repo:   string(repo.RepoAt()),
 					Branch: targetBranch,
 				},
-				Patch:     blob.Blob.Ref.String(),
+				PatchBlob: blob.Blob,
 				Source:    recordPullSource,
 				CreatedAt: time.Now().Format(time.RFC3339),
 			},
···
 		}
 
 		record := p.AsRecord()
-		record.Patch = blob.Blob.Ref.String()
+		record.PatchBlob = blob.Blob
 		writes = append(writes, &comatproto.RepoApplyWrites_Input_Writes_Elem{
 			RepoApplyWrites_Create: &comatproto.RepoApplyWrites_Create{
 				Collection: tangled.RepoPullNSID,
···
 		return
 	}
 	record := pull.AsRecord()
-	record.Patch = blob.Blob.Ref.String()
+	record.PatchBlob = blob.Blob
 	record.CreatedAt = time.Now().Format(time.RFC3339)
 
 	_, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
···
 			return
 		}
 		record := p.AsRecord()
-		record.Patch = blob.Blob.Ref.String()
+		record.PatchBlob = blob.Blob
 		writes = append(writes, &comatproto.RepoApplyWrites_Input_Writes_Elem{
 			RepoApplyWrites_Create: &comatproto.RepoApplyWrites_Create{
 				Collection: tangled.RepoPullNSID,
···
 			return
 		}
 		record := np.AsRecord()
-		record.Patch = blob.Blob.Ref.String()
+		record.PatchBlob = blob.Blob
 		writes = append(writes, &comatproto.RepoApplyWrites_Input_Writes_Elem{
 			RepoApplyWrites_Update: &comatproto.RepoApplyWrites_Update{
 				Collection: tangled.RepoPullNSID,

lexicons/pulls/pull.json

···
         "required": [
           "target",
           "title",
-          "patch",
+          "patchBlob",
           "createdAt"
         ],
         "properties": {
···
             "type": "string"
           },
           "patch": {
-            "type": "string"
+            "type": "string",
+            "description": "(deprecated) use patchBlob instead"
+          },
+          "patchBlob": {
+            "type": "blob",
+            "accept": "text/x-patch",
+            "description": "patch content"
           },
           "source": {
             "type": "ref",