0
0
package plc
import (
"encoding/json"
"fmt"
"maps"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/strs"
)
const (
TypeOperation = "plc_operation"
TypeTombstone = "plc_tombstone"
TypeCreate = "create"
)
type Service struct {
Type string `json:"type"`
Endpoint string `json:"endpoint"`
}
type Operation struct {
Type string
Prev *string
RotationKeys []string
VerificationMethods map[string]string
AlsoKnownAs []string
Services map[string]Service
SigningKey string
RecoveryKey string
Handle string
Service string
Sig string
raw map[string]any
}
type LogEntry struct {
DID string `json:"did"`
Operation Operation `json:"operation"`
CID string `json:"cid"`
Nullified bool `json:"nullified"`
CreatedAt string `json:"createdAt"`
}
type VerificationMethod struct {
ID string `json:"id"`
Type string `json:"type"`
Controller string `json:"controller"`
PublicKeyMultibase string `json:"publicKeyMultibase"`
}
type DIDService struct {
ID string `json:"id"`
Type string `json:"type"`
ServiceEndpoint string `json:"serviceEndpoint"`
}
type DIDDocument struct {
Context []string `json:"@context"`
ID string `json:"id"`
AlsoKnownAs []string `json:"alsoKnownAs,omitempty"`
VerificationMethod []VerificationMethod `json:"verificationMethod,omitempty"`
Service []DIDService `json:"service,omitempty"`
}
func (o Operation) MarshalJSON() ([]byte, error) {
if o.raw != nil {
return json.Marshal(o.raw)
}
return json.Marshal(o.object())
}
func (o *Operation) UnmarshalJSON(b []byte) error {
var raw map[string]any
if err := json.Unmarshal(b, &raw); err != nil {
return err
}
o.fromObject(raw)
o.raw = raw
return nil
}
func NewOperationFromObject(raw map[string]any) *Operation {
op := &Operation{}
op.fromObject(raw)
op.raw = raw
return op
}
func (o *Operation) SignedObject() map[string]any {
m := o.object()
if o.Sig != "" {
m["sig"] = o.Sig
}
return m
}
func (o *Operation) UnsignedObject() map[string]any {
m := o.object()
delete(m, "sig")
return m
}
func (o *Operation) object() map[string]any {
if o.raw != nil {
out := make(map[string]any, len(o.raw))
maps.Copy(out, o.raw)
return out
}
m := map[string]any{"type": o.Type}
switch o.Type {
case TypeOperation:
m["rotationKeys"] = strs.AnySlice(o.RotationKeys)
m["verificationMethods"] = strs.AnyMap(o.VerificationMethods)
m["alsoKnownAs"] = strs.AnySlice(o.AlsoKnownAs)
services := make(map[string]any, len(o.Services))
for k, v := range o.Services {
services[k] = map[string]any{"type": v.Type, "endpoint": v.Endpoint}
}
m["services"] = services
if o.Prev != nil {
m["prev"] = *o.Prev
} else {
m["prev"] = nil
}
case TypeTombstone:
if o.Prev != nil {
m["prev"] = *o.Prev
} else {
m["prev"] = nil
}
case TypeCreate:
m["signingKey"] = o.SigningKey
m["recoveryKey"] = o.RecoveryKey
m["handle"] = o.Handle
m["service"] = o.Service
}
if o.Sig != "" {
m["sig"] = o.Sig
}
return m
}
func (o *Operation) fromObject(raw map[string]any) {
o.raw = nil
o.Type, _ = raw["type"].(string)
o.Sig, _ = raw["sig"].(string)
o.Prev = nil
if v, ok := raw["prev"]; ok && v != nil {
if s, ok := v.(string); ok {
o.Prev = &s
}
}
o.RotationKeys = stringsFromAny(raw["rotationKeys"])
o.VerificationMethods = stringMapFromAny(raw["verificationMethods"])
o.AlsoKnownAs = stringsFromAny(raw["alsoKnownAs"])
o.Services = servicesFromAny(raw["services"])
o.SigningKey, _ = raw["signingKey"].(string)
o.RecoveryKey, _ = raw["recoveryKey"].(string)
o.Handle, _ = raw["handle"].(string)
o.Service, _ = raw["service"].(string)
}
func stringsFromAny(v any) []string {
arr, _ := v.([]any)
out := make([]string, 0, len(arr))
for _, el := range arr {
if s, ok := el.(string); ok {
out = append(out, s)
}
}
return out
}
func stringMapFromAny(v any) map[string]string {
m, _ := v.(map[string]any)
out := make(map[string]string, len(m))
for k, el := range m {
if s, ok := el.(string); ok {
out[k] = s
}
}
return out
}
func servicesFromAny(v any) map[string]Service {
m, _ := v.(map[string]any)
out := make(map[string]Service, len(m))
for k, el := range m {
svc, ok := el.(map[string]any)
if !ok {
continue
}
s := Service{}
s.Type, _ = svc["type"].(string)
s.Endpoint, _ = svc["endpoint"].(string)
out[k] = s
}
return out
}
func ValidateStructure(raw map[string]any) string {
if raw == nil {
return "Operation must be an object"
}
typ, _ := raw["type"].(string)
switch typ {
case TypeOperation:
if _, ok := raw["rotationKeys"].([]any); !ok {
return "rotationKeys must be an array"
}
if v, ok := raw["verificationMethods"]; ok && v != nil {
if _, ok := v.(map[string]any); !ok {
return "verificationMethods must be an object"
}
}
if v, ok := raw["alsoKnownAs"]; ok && v != nil {
if _, ok := v.([]any); !ok {
return "alsoKnownAs must be an array"
}
}
if v, ok := raw["services"]; ok && v != nil {
if _, ok := v.(map[string]any); !ok {
return "services must be an object"
}
}
if _, ok := raw["sig"].(string); !ok {
return "sig must be a string"
}
if v, ok := raw["prev"]; ok && v != nil {
if _, ok := v.(string); !ok {
return "prev must be null or a CID string"
}
}
return ""
case TypeTombstone:
if _, ok := raw["prev"].(string); !ok {
return "prev must be a CID string"
}
if _, ok := raw["sig"].(string); !ok {
return "sig must be a string"
}
return ""
case TypeCreate:
if _, ok := raw["signingKey"].(string); !ok {
return "signingKey must be a string"
}
if _, ok := raw["recoveryKey"].(string); !ok {
return "recoveryKey must be a string"
}
if _, ok := raw["handle"].(string); !ok {
return "handle must be a string"
}
if _, ok := raw["service"].(string); !ok {
return "service must be a string"
}
if _, ok := raw["sig"].(string); !ok {
return "sig must be a string"
}
return ""
default:
if raw["type"] == nil {
return "Unknown operation type: undefined"
}
return fmt.Sprintf("Unknown operation type: %v", raw["type"])
}
}