johnandersen777.bsky.social/socialweb-computer-kcp

Switch repository

Loading…

// Code generated by lexgen from lexicons/. DO NOT EDIT.

package infra

import (
	"bytes"
	"encoding/json"
	"fmt"

	"github.com/bluesky-social/indigo/atproto/atdata"

	"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/b64"
)

type Record interface {
	NSID() string
}

func EncodeRecord(r Record) (map[string]any, error) {
	b, err := json.Marshal(r)
	if err != nil {
		return nil, err
	}
	return atdata.UnmarshalJSON(b)
}

func decodeRecord(value map[string]any, nsid string, out any) error {
	if got, _ := value["$type"].(string); got != nsid {
		return fmt.Errorf("%w: expected $type %s, got %q", ErrInvalidRecord, nsid, got)
	}
	b, err := json.Marshal(b64.NormalizeJSON(value))
	if err != nil {
		return fmt.Errorf("%w: %v", ErrInvalidRecord, err)
	}
	if err := json.Unmarshal(b, out); err != nil {
		return fmt.Errorf("%w: %v", ErrInvalidRecord, err)
	}
	if v, ok := out.(interface{ Validate() error }); ok {
		return v.Validate()
	}
	return nil
}

func marshalOpen(v any, extra, absent map[string]json.RawMessage) ([]byte, error) {
	b, err := json.Marshal(v)
	if err != nil || len(extra)+len(absent) == 0 {
		return b, err
	}
	fields := map[string]json.RawMessage{}
	if err := json.Unmarshal(b, &fields); err != nil {
		return nil, err
	}
	for k, raw := range absent {
		if bytes.Equal(fields[k], raw) {
			delete(fields, k)
		}
	}
	for k, raw := range extra {
		if _, ok := fields[k]; !ok {
			fields[k] = raw
		}
	}
	return json.Marshal(fields)
}

func unmarshalOpen(b []byte, v any) (extra, absent map[string]json.RawMessage, err error) {
	if err := json.Unmarshal(b, v); err != nil {
		return nil, nil, err
	}
	var in map[string]json.RawMessage
	if err := json.Unmarshal(b, &in); err != nil {
		return nil, nil, err
	}
	encoded, err := json.Marshal(v)
	if err != nil {
		return nil, nil, err
	}
	var kept map[string]json.RawMessage
	if err := json.Unmarshal(encoded, &kept); err != nil {
		return nil, nil, err
	}
	return missing(in, kept), missing(kept, in), nil
}

func missing(from, in map[string]json.RawMessage) map[string]json.RawMessage {
	var out map[string]json.RawMessage
	for k, raw := range from {
		if _, ok := in[k]; ok {
			continue
		}
		if out == nil {
			out = map[string]json.RawMessage{}
		}
		out[k] = raw
	}
	return out
}

type EphemeralInfra struct {
	Type        string                     `json:"$type"`
	Contracts   []InfraContract            `json:"contracts,omitempty"`
	CreatedAt   string                     `json:"createdAt"`
	Description string                     `json:"description,omitempty"`
	EndWhen     string                     `json:"endWhen,omitempty"`
	Status      *EphemeralInfraStatus      `json:"status,omitempty"`
	TtlSeconds  int64                      `json:"ttlSeconds"`
	Extra       map[string]json.RawMessage `json:"-"`
	absent      map[string]json.RawMessage
}

func (EphemeralInfra) NSID() string {
	return "computer.socialweb.ephemeralInfra"
}

func ParseEphemeralInfra(value map[string]any) (*EphemeralInfra, error) {
	var out EphemeralInfra
	if err := decodeRecord(value, "computer.socialweb.ephemeralInfra", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v EphemeralInfra) MarshalJSON() ([]byte, error) {
	type plain EphemeralInfra
	if v.Type == "" {
		v.Type = "computer.socialweb.ephemeralInfra"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *EphemeralInfra) UnmarshalJSON(b []byte) error {
	type plain EphemeralInfra
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = EphemeralInfra(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type EphemeralInfraStatus struct {
	Contracts []InfraContractStatus      `json:"contracts,omitempty"`
	EndReason string                     `json:"endReason,omitempty"`
	EndedAt   string                     `json:"endedAt,omitempty"`
	ExpiresAt string                     `json:"expiresAt,omitempty"`
	Phase     string                     `json:"phase"`
	Extra     map[string]json.RawMessage `json:"-"`
	absent    map[string]json.RawMessage
}

func (v EphemeralInfraStatus) MarshalJSON() ([]byte, error) {
	type plain EphemeralInfraStatus
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *EphemeralInfraStatus) UnmarshalJSON(b []byte) error {
	type plain EphemeralInfraStatus
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = EphemeralInfraStatus(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type Infra struct {
	Type        string                     `json:"$type"`
	Contracts   []InfraContract            `json:"contracts,omitempty"`
	CreatedAt   string                     `json:"createdAt"`
	Description string                     `json:"description,omitempty"`
	Index       *InfraIndex                `json:"index,omitempty"`
	Status      *InfraStatus               `json:"status,omitempty"`
	Extra       map[string]json.RawMessage `json:"-"`
	absent      map[string]json.RawMessage
}

func (Infra) NSID() string {
	return "computer.socialweb.infra"
}

func ParseInfra(value map[string]any) (*Infra, error) {
	var out Infra
	if err := decodeRecord(value, "computer.socialweb.infra", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v Infra) MarshalJSON() ([]byte, error) {
	type plain Infra
	if v.Type == "" {
		v.Type = "computer.socialweb.infra"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *Infra) UnmarshalJSON(b []byte) error {
	type plain Infra
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = Infra(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type InfraAgent struct {
	EnvFile string                     `json:"envFile,omitempty"`
	Extra   map[string]json.RawMessage `json:"-"`
	absent  map[string]json.RawMessage
}

func (v InfraAgent) MarshalJSON() ([]byte, error) {
	type plain InfraAgent
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *InfraAgent) UnmarshalJSON(b []byte) error {
	type plain InfraAgent
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = InfraAgent(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type InfraAssociation struct {
	FromGuest bool                       `json:"fromGuest,omitempty"`
	RefFile   string                     `json:"refFile,omitempty"`
	Subject   string                     `json:"subject,omitempty"`
	Extra     map[string]json.RawMessage `json:"-"`
	absent    map[string]json.RawMessage
}

func (v InfraAssociation) MarshalJSON() ([]byte, error) {
	type plain InfraAssociation
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *InfraAssociation) UnmarshalJSON(b []byte) error {
	type plain InfraAssociation
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = InfraAssociation(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type InfraContract struct {
	Agent              *InfraAgent                `json:"agent,omitempty"`
	Association        *InfraAssociation          `json:"association,omitempty"`
	BidderDids         []string                   `json:"bidderDids,omitempty"`
	ComputeKind        string                     `json:"computeKind,omitempty"`
	DenyBidderDids     []string                   `json:"denyBidderDids,omitempty"`
	GuestTools         []string                   `json:"guestTools,omitempty"`
	Name               string                     `json:"name"`
	Policy             string                     `json:"policy,omitempty"`
	PolicyArgs         string                     `json:"policyArgs,omitempty"`
	ReleaseRequestedAt string                     `json:"releaseRequestedAt,omitempty"`
	SSHAuthorizedKeys  []string                   `json:"sshAuthorizedKeys,omitempty"`
	State              string                     `json:"state"`
	Tunnels            []InfraTunnel              `json:"tunnels,omitempty"`
	UserData           string                     `json:"userData,omitempty"`
	VMName             string                     `json:"vmName,omitempty"`
	VMReadyTimeoutSec  int64                      `json:"vmReadyTimeoutSec,omitempty"`
	Extra              map[string]json.RawMessage `json:"-"`
	absent             map[string]json.RawMessage
}

func (v InfraContract) MarshalJSON() ([]byte, error) {
	type plain InfraContract
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *InfraContract) UnmarshalJSON(b []byte) error {
	type plain InfraContract
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = InfraContract(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type InfraContractStatus struct {
	Message string                     `json:"message,omitempty"`
	Name    string                     `json:"name"`
	Phase   string                     `json:"phase"`
	Receipt string                     `json:"receipt,omitempty"`
	Winner  string                     `json:"winner,omitempty"`
	Extra   map[string]json.RawMessage `json:"-"`
	absent  map[string]json.RawMessage
}

func (v InfraContractStatus) MarshalJSON() ([]byte, error) {
	type plain InfraContractStatus
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *InfraContractStatus) UnmarshalJSON(b []byte) error {
	type plain InfraContractStatus
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = InfraContractStatus(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type InfraIndex struct {
	Live        []InfraIndexEntry          `json:"live,omitempty"`
	RecentEnded []InfraIndexEnded          `json:"recentEnded,omitempty"`
	UpdatedAt   string                     `json:"updatedAt"`
	Extra       map[string]json.RawMessage `json:"-"`
	absent      map[string]json.RawMessage
}

func (v InfraIndex) MarshalJSON() ([]byte, error) {
	type plain InfraIndex
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *InfraIndex) UnmarshalJSON(b []byte) error {
	type plain InfraIndex
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = InfraIndex(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type InfraIndexEnded struct {
	Collection string                     `json:"collection"`
	EndReason  string                     `json:"endReason,omitempty"`
	EndedAt    string                     `json:"endedAt"`
	Rkey       string                     `json:"rkey"`
	Extra      map[string]json.RawMessage `json:"-"`
	absent     map[string]json.RawMessage
}

func (v InfraIndexEnded) MarshalJSON() ([]byte, error) {
	type plain InfraIndexEnded
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *InfraIndexEnded) UnmarshalJSON(b []byte) error {
	type plain InfraIndexEnded
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = InfraIndexEnded(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type InfraIndexEntry struct {
	AddedAt    string                     `json:"addedAt"`
	Collection string                     `json:"collection"`
	CreatedAt  string                     `json:"createdAt"`
	ExpiresAt  string                     `json:"expiresAt,omitempty"`
	Rkey       string                     `json:"rkey"`
	Writer     string                     `json:"writer,omitempty"`
	Extra      map[string]json.RawMessage `json:"-"`
	absent     map[string]json.RawMessage
}

func (v InfraIndexEntry) MarshalJSON() ([]byte, error) {
	type plain InfraIndexEntry
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *InfraIndexEntry) UnmarshalJSON(b []byte) error {
	type plain InfraIndexEntry
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = InfraIndexEntry(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type InfraShell struct {
	EnvFile string                     `json:"envFile,omitempty"`
	Extra   map[string]json.RawMessage `json:"-"`
	absent  map[string]json.RawMessage
}

func (v InfraShell) MarshalJSON() ([]byte, error) {
	type plain InfraShell
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *InfraShell) UnmarshalJSON(b []byte) error {
	type plain InfraShell
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = InfraShell(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type InfraStatus struct {
	Contracts []InfraContractStatus      `json:"contracts,omitempty"`
	EndReason string                     `json:"endReason,omitempty"`
	EndedAt   string                     `json:"endedAt,omitempty"`
	Phase     string                     `json:"phase"`
	Extra     map[string]json.RawMessage `json:"-"`
	absent    map[string]json.RawMessage
}

func (v InfraStatus) MarshalJSON() ([]byte, error) {
	type plain InfraStatus
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *InfraStatus) UnmarshalJSON(b []byte) error {
	type plain InfraStatus
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = InfraStatus(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type InfraTunnel struct {
	Port      int64                      `json:"port"`
	Server    string                     `json:"server,omitempty"`
	Shell     *InfraShell                `json:"shell,omitempty"`
	Tag       string                     `json:"tag"`
	Transport string                     `json:"transport,omitempty"`
	Extra     map[string]json.RawMessage `json:"-"`
	absent    map[string]json.RawMessage
}

func (v InfraTunnel) MarshalJSON() ([]byte, error) {
	type plain InfraTunnel
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *InfraTunnel) UnmarshalJSON(b []byte) error {
	type plain InfraTunnel
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = InfraTunnel(p)
	v.Extra = extra
	v.absent = absent
	return nil
}