mstar/linstrom
1
0
Fork 0
Code Issues 3 Pull requests Projects Releases Packages 1 Wiki Activity Actions 1

Work on ensuring data consistency even for yet unknown fields
Some checks failed
/ docker (push) Has been cancelled
Details

Browse source
This commit is contained in:
Melody Becker 2025-05-28 16:52:54 +02:00
parent 7e10627618
commit bf0aaaca8f
Signed by: mstar
SSH key fingerprint: SHA256:9VAo09aaVNTWKzPW7Hq2LW+ox9OdwmTSHRoD4mlz1yI
12 changed files with 458 additions and 5 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
storage-new/dbgen/activities.gen.go
View file

@ -31,6 +31,7 @@ func newActivity(db *gorm.DB, opts ...gen.DOOption) activity {
_activity.Type = field.NewString(tableName, "type")
_activity.ObjectId = field.NewString(tableName, "object_id")
_activity.ObjectType = field.NewUint32(tableName, "object_type")
_activity.RawData = field.NewBytes(tableName, "raw_data")
_activity.fillFieldMap()
@ -45,6 +46,7 @@ type activity struct {
Type field.String
ObjectId field.String
ObjectType field.Uint32
RawData field.Bytes
fieldMap map[string]field.Expr
}
@ -65,6 +67,7 @@ func (a *activity) updateTableName(table string) *activity {
a.Type = field.NewString(table, "type")
a.ObjectId = field.NewString(table, "object_id")
a.ObjectType = field.NewUint32(table, "object_type")
a.RawData = field.NewBytes(table, "raw_data")
a.fillFieldMap()
@ -81,11 +84,12 @@ func (a *activity) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
}
func (a *activity) fillFieldMap() {
a.fieldMap = make(map[string]field.Expr, 4)
a.fieldMap = make(map[string]field.Expr, 5)
a.fieldMap["id"] = a.Id
a.fieldMap["type"] = a.Type
a.fieldMap["object_id"] = a.ObjectId
a.fieldMap["object_type"] = a.ObjectType
a.fieldMap["raw_data"] = a.RawData
}
func (a activity) clone(db *gorm.DB) activity {

8
storage-new/dbgen/gen.go
View file

@ -38,6 +38,7 @@ var (
RemoteServerMetadata *remoteServerMetadata
Role *role
ServerMetadata *serverMetadata
UnhandledMessage *unhandledMessage
User *user
UserAuthMethod *userAuthMethod
UserInfoField *userInfoField
@ -72,6 +73,7 @@ func SetDefault(db *gorm.DB, opts ...gen.DOOption) {
RemoteServerMetadata = &Q.RemoteServerMetadata
Role = &Q.Role
ServerMetadata = &Q.ServerMetadata
UnhandledMessage = &Q.UnhandledMessage
User = &Q.User
UserAuthMethod = &Q.UserAuthMethod
UserInfoField = &Q.UserInfoField
@ -107,6 +109,7 @@ func Use(db *gorm.DB, opts ...gen.DOOption) *Query {
RemoteServerMetadata: newRemoteServerMetadata(db, opts...),
Role: newRole(db, opts...),
ServerMetadata: newServerMetadata(db, opts...),
UnhandledMessage: newUnhandledMessage(db, opts...),
User: newUser(db, opts...),
UserAuthMethod: newUserAuthMethod(db, opts...),
UserInfoField: newUserInfoField(db, opts...),
@ -143,6 +146,7 @@ type Query struct {
RemoteServerMetadata remoteServerMetadata
Role role
ServerMetadata serverMetadata
UnhandledMessage unhandledMessage
User user
UserAuthMethod userAuthMethod
UserInfoField userInfoField
@ -180,6 +184,7 @@ func (q *Query) clone(db *gorm.DB) *Query {
RemoteServerMetadata: q.RemoteServerMetadata.clone(db),
Role: q.Role.clone(db),
ServerMetadata: q.ServerMetadata.clone(db),
UnhandledMessage: q.UnhandledMessage.clone(db),
User: q.User.clone(db),
UserAuthMethod: q.UserAuthMethod.clone(db),
UserInfoField: q.UserInfoField.clone(db),
@ -224,6 +229,7 @@ func (q *Query) ReplaceDB(db *gorm.DB) *Query {
RemoteServerMetadata: q.RemoteServerMetadata.replaceDB(db),
Role: q.Role.replaceDB(db),
ServerMetadata: q.ServerMetadata.replaceDB(db),
UnhandledMessage: q.UnhandledMessage.replaceDB(db),
User: q.User.replaceDB(db),
UserAuthMethod: q.UserAuthMethod.replaceDB(db),
UserInfoField: q.UserInfoField.replaceDB(db),
@ -258,6 +264,7 @@ type queryCtx struct {
RemoteServerMetadata IRemoteServerMetadataDo
Role IRoleDo
ServerMetadata IServerMetadataDo
UnhandledMessage IUnhandledMessageDo
User IUserDo
UserAuthMethod IUserAuthMethodDo
UserInfoField IUserInfoFieldDo
@ -292,6 +299,7 @@ func (q *Query) WithContext(ctx context.Context) *queryCtx {
RemoteServerMetadata: q.RemoteServerMetadata.WithContext(ctx),
Role: q.Role.WithContext(ctx),
ServerMetadata: q.ServerMetadata.WithContext(ctx),
UnhandledMessage: q.UnhandledMessage.WithContext(ctx),
User: q.User.WithContext(ctx),
UserAuthMethod: q.UserAuthMethod.WithContext(ctx),
UserInfoField: q.UserInfoField.WithContext(ctx),

6
storage-new/dbgen/notes.gen.go
View file

@ -40,6 +40,7 @@ func newNote(db *gorm.DB, opts ...gen.DOOption) note {
_note.Quotes = field.NewField(tableName, "quotes")
_note.AccessLevel = field.NewField(tableName, "access_level")
_note.OriginId = field.NewUint(tableName, "origin_id")
_note.RawData = field.NewBytes(tableName, "raw_data")
_note.AttachmentRelations = noteHasManyAttachmentRelations{
db: db.Session(&gorm.Session{}),
@ -580,6 +581,7 @@ type note struct {
Quotes field.Field
AccessLevel field.Field
OriginId field.Uint
RawData field.Bytes
AttachmentRelations noteHasManyAttachmentRelations
EmoteRelations noteHasManyEmoteRelations
@ -621,6 +623,7 @@ func (n *note) updateTableName(table string) *note {
n.Quotes = field.NewField(table, "quotes")
n.AccessLevel = field.NewField(table, "access_level")
n.OriginId = field.NewUint(table, "origin_id")
n.RawData = field.NewBytes(table, "raw_data")
n.fillFieldMap()
@ -637,7 +640,7 @@ func (n *note) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
}
func (n *note) fillFieldMap() {
n.fieldMap = make(map[string]field.Expr, 19)
n.fieldMap = make(map[string]field.Expr, 20)
n.fieldMap["id"] = n.ID
n.fieldMap["created_at"] = n.CreatedAt
n.fieldMap["updated_at"] = n.UpdatedAt
@ -650,6 +653,7 @@ func (n *note) fillFieldMap() {
n.fieldMap["quotes"] = n.Quotes
n.fieldMap["access_level"] = n.AccessLevel
n.fieldMap["origin_id"] = n.OriginId
n.fieldMap["raw_data"] = n.RawData
}

6
storage-new/dbgen/server_metadata.gen.go
View file

@ -38,6 +38,7 @@ func newServerMetadata(db *gorm.DB, opts ...gen.DOOption) serverMetadata {
_serverMetadata.LEIssuerCertificate = field.NewBytes(tableName, "le_issuer_certificate")
_serverMetadata.LECSR = field.NewBytes(tableName, "lecsr")
_serverMetadata.LELastUpdate = field.NewField(tableName, "le_last_update")
_serverMetadata.LEUserPrivKey = field.NewBytes(tableName, "le_user_priv_key")
_serverMetadata.fillFieldMap()
@ -59,6 +60,7 @@ type serverMetadata struct {
LEIssuerCertificate field.Bytes
LECSR field.Bytes
LELastUpdate field.Field
LEUserPrivKey field.Bytes
fieldMap map[string]field.Expr
}
@ -86,6 +88,7 @@ func (s *serverMetadata) updateTableName(table string) *serverMetadata {
s.LEIssuerCertificate = field.NewBytes(table, "le_issuer_certificate")
s.LECSR = field.NewBytes(table, "lecsr")
s.LELastUpdate = field.NewField(table, "le_last_update")
s.LEUserPrivKey = field.NewBytes(table, "le_user_priv_key")
s.fillFieldMap()
@ -102,7 +105,7 @@ func (s *serverMetadata) GetFieldByName(fieldName string) (field.OrderExpr, bool
}
func (s *serverMetadata) fillFieldMap() {
s.fieldMap = make(map[string]field.Expr, 11)
s.fieldMap = make(map[string]field.Expr, 12)
s.fieldMap["id"] = s.Id
s.fieldMap["created_at"] = s.CreatedAt
s.fieldMap["updated_at"] = s.UpdatedAt
@ -114,6 +117,7 @@ func (s *serverMetadata) fillFieldMap() {
s.fieldMap["le_issuer_certificate"] = s.LEIssuerCertificate
s.fieldMap["lecsr"] = s.LECSR
s.fieldMap["le_last_update"] = s.LELastUpdate
s.fieldMap["le_user_priv_key"] = s.LEUserPrivKey
}
func (s serverMetadata) clone(db *gorm.DB) serverMetadata {

398
storage-new/dbgen/unhandled_messages.gen.go Normal file
View file

@ -0,0 +1,398 @@
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
package dbgen
import (
"context"
"database/sql"
"git.mstar.dev/mstar/linstrom/storage-new/models"
"gorm.io/gorm"
"gorm.io/gorm/clause"
"gorm.io/gorm/schema"
"gorm.io/gen"
"gorm.io/gen/field"
"gorm.io/plugin/dbresolver"
)
func newUnhandledMessage(db *gorm.DB, opts ...gen.DOOption) unhandledMessage {
_unhandledMessage := unhandledMessage{}
_unhandledMessage.unhandledMessageDo.UseDB(db, opts...)
_unhandledMessage.unhandledMessageDo.UseModel(&models.UnhandledMessage{})
tableName := _unhandledMessage.unhandledMessageDo.TableName()
_unhandledMessage.ALL = field.NewAsterisk(tableName)
_unhandledMessage.ID = field.NewUint64(tableName, "id")
_unhandledMessage.CreatedAt = field.NewTime(tableName, "created_at")
_unhandledMessage.RawData = field.NewBytes(tableName, "raw_data")
_unhandledMessage.ForUserId = field.NewString(tableName, "for_user_id")
_unhandledMessage.GlobalInbox = field.NewBool(tableName, "global_inbox")
_unhandledMessage.fillFieldMap()
return _unhandledMessage
}
type unhandledMessage struct {
unhandledMessageDo
ALL field.Asterisk
ID field.Uint64
CreatedAt field.Time
RawData field.Bytes
ForUserId field.String
GlobalInbox field.Bool
fieldMap map[string]field.Expr
}
func (u unhandledMessage) Table(newTableName string) *unhandledMessage {
u.unhandledMessageDo.UseTable(newTableName)
return u.updateTableName(newTableName)
}
func (u unhandledMessage) As(alias string) *unhandledMessage {
u.unhandledMessageDo.DO = *(u.unhandledMessageDo.As(alias).(*gen.DO))
return u.updateTableName(alias)
}
func (u *unhandledMessage) updateTableName(table string) *unhandledMessage {
u.ALL = field.NewAsterisk(table)
u.ID = field.NewUint64(table, "id")
u.CreatedAt = field.NewTime(table, "created_at")
u.RawData = field.NewBytes(table, "raw_data")
u.ForUserId = field.NewString(table, "for_user_id")
u.GlobalInbox = field.NewBool(table, "global_inbox")
u.fillFieldMap()
return u
}
func (u *unhandledMessage) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
_f, ok := u.fieldMap[fieldName]
if !ok || _f == nil {
return nil, false
}
_oe, ok := _f.(field.OrderExpr)
return _oe, ok
}
func (u *unhandledMessage) fillFieldMap() {
u.fieldMap = make(map[string]field.Expr, 5)
u.fieldMap["id"] = u.ID
u.fieldMap["created_at"] = u.CreatedAt
u.fieldMap["raw_data"] = u.RawData
u.fieldMap["for_user_id"] = u.ForUserId
u.fieldMap["global_inbox"] = u.GlobalInbox
}
func (u unhandledMessage) clone(db *gorm.DB) unhandledMessage {
u.unhandledMessageDo.ReplaceConnPool(db.Statement.ConnPool)
return u
}
func (u unhandledMessage) replaceDB(db *gorm.DB) unhandledMessage {
u.unhandledMessageDo.ReplaceDB(db)
return u
}
type unhandledMessageDo struct{ gen.DO }
type IUnhandledMessageDo interface {
gen.SubQuery
Debug() IUnhandledMessageDo
WithContext(ctx context.Context) IUnhandledMessageDo
WithResult(fc func(tx gen.Dao)) gen.ResultInfo
ReplaceDB(db *gorm.DB)
ReadDB() IUnhandledMessageDo
WriteDB() IUnhandledMessageDo
As(alias string) gen.Dao
Session(config *gorm.Session) IUnhandledMessageDo
Columns(cols ...field.Expr) gen.Columns
Clauses(conds ...clause.Expression) IUnhandledMessageDo
Not(conds ...gen.Condition) IUnhandledMessageDo
Or(conds ...gen.Condition) IUnhandledMessageDo
Select(conds ...field.Expr) IUnhandledMessageDo
Where(conds ...gen.Condition) IUnhandledMessageDo
Order(conds ...field.Expr) IUnhandledMessageDo
Distinct(cols ...field.Expr) IUnhandledMessageDo
Omit(cols ...field.Expr) IUnhandledMessageDo
Join(table schema.Tabler, on ...field.Expr) IUnhandledMessageDo
LeftJoin(table schema.Tabler, on ...field.Expr) IUnhandledMessageDo
RightJoin(table schema.Tabler, on ...field.Expr) IUnhandledMessageDo
Group(cols ...field.Expr) IUnhandledMessageDo
Having(conds ...gen.Condition) IUnhandledMessageDo
Limit(limit int) IUnhandledMessageDo
Offset(offset int) IUnhandledMessageDo
Count() (count int64, err error)
Scopes(funcs ...func(gen.Dao) gen.Dao) IUnhandledMessageDo
Unscoped() IUnhandledMessageDo
Create(values ...*models.UnhandledMessage) error
CreateInBatches(values []*models.UnhandledMessage, batchSize int) error
Save(values ...*models.UnhandledMessage) error
First() (*models.UnhandledMessage, error)
Take() (*models.UnhandledMessage, error)
Last() (*models.UnhandledMessage, error)
Find() ([]*models.UnhandledMessage, error)
FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.UnhandledMessage, err error)
FindInBatches(result *[]*models.UnhandledMessage, batchSize int, fc func(tx gen.Dao, batch int) error) error
Pluck(column field.Expr, dest interface{}) error
Delete(...*models.UnhandledMessage) (info gen.ResultInfo, err error)
Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
Updates(value interface{}) (info gen.ResultInfo, err error)
UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
UpdateFrom(q gen.SubQuery) gen.Dao
Attrs(attrs ...field.AssignExpr) IUnhandledMessageDo
Assign(attrs ...field.AssignExpr) IUnhandledMessageDo
Joins(fields ...field.RelationField) IUnhandledMessageDo
Preload(fields ...field.RelationField) IUnhandledMessageDo
FirstOrInit() (*models.UnhandledMessage, error)
FirstOrCreate() (*models.UnhandledMessage, error)
FindByPage(offset int, limit int) (result []*models.UnhandledMessage, count int64, err error)
ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
Rows() (*sql.Rows, error)
Row() *sql.Row
Scan(result interface{}) (err error)
Returning(value interface{}, columns ...string) IUnhandledMessageDo
UnderlyingDB() *gorm.DB
schema.Tabler
}
func (u unhandledMessageDo) Debug() IUnhandledMessageDo {
return u.withDO(u.DO.Debug())
}
func (u unhandledMessageDo) WithContext(ctx context.Context) IUnhandledMessageDo {
return u.withDO(u.DO.WithContext(ctx))
}
func (u unhandledMessageDo) ReadDB() IUnhandledMessageDo {
return u.Clauses(dbresolver.Read)
}
func (u unhandledMessageDo) WriteDB() IUnhandledMessageDo {
return u.Clauses(dbresolver.Write)
}
func (u unhandledMessageDo) Session(config *gorm.Session) IUnhandledMessageDo {
return u.withDO(u.DO.Session(config))
}
func (u unhandledMessageDo) Clauses(conds ...clause.Expression) IUnhandledMessageDo {
return u.withDO(u.DO.Clauses(conds...))
}
func (u unhandledMessageDo) Returning(value interface{}, columns ...string) IUnhandledMessageDo {
return u.withDO(u.DO.Returning(value, columns...))
}
func (u unhandledMessageDo) Not(conds ...gen.Condition) IUnhandledMessageDo {
return u.withDO(u.DO.Not(conds...))
}
func (u unhandledMessageDo) Or(conds ...gen.Condition) IUnhandledMessageDo {
return u.withDO(u.DO.Or(conds...))
}
func (u unhandledMessageDo) Select(conds ...field.Expr) IUnhandledMessageDo {
return u.withDO(u.DO.Select(conds...))
}
func (u unhandledMessageDo) Where(conds ...gen.Condition) IUnhandledMessageDo {
return u.withDO(u.DO.Where(conds...))
}
func (u unhandledMessageDo) Order(conds ...field.Expr) IUnhandledMessageDo {
return u.withDO(u.DO.Order(conds...))
}
func (u unhandledMessageDo) Distinct(cols ...field.Expr) IUnhandledMessageDo {
return u.withDO(u.DO.Distinct(cols...))
}
func (u unhandledMessageDo) Omit(cols ...field.Expr) IUnhandledMessageDo {
return u.withDO(u.DO.Omit(cols...))
}
func (u unhandledMessageDo) Join(table schema.Tabler, on ...field.Expr) IUnhandledMessageDo {
return u.withDO(u.DO.Join(table, on...))
}
func (u unhandledMessageDo) LeftJoin(table schema.Tabler, on ...field.Expr) IUnhandledMessageDo {
return u.withDO(u.DO.LeftJoin(table, on...))
}
func (u unhandledMessageDo) RightJoin(table schema.Tabler, on ...field.Expr) IUnhandledMessageDo {
return u.withDO(u.DO.RightJoin(table, on...))
}
func (u unhandledMessageDo) Group(cols ...field.Expr) IUnhandledMessageDo {
return u.withDO(u.DO.Group(cols...))
}
func (u unhandledMessageDo) Having(conds ...gen.Condition) IUnhandledMessageDo {
return u.withDO(u.DO.Having(conds...))
}
func (u unhandledMessageDo) Limit(limit int) IUnhandledMessageDo {
return u.withDO(u.DO.Limit(limit))
}
func (u unhandledMessageDo) Offset(offset int) IUnhandledMessageDo {
return u.withDO(u.DO.Offset(offset))
}
func (u unhandledMessageDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IUnhandledMessageDo {
return u.withDO(u.DO.Scopes(funcs...))
}
func (u unhandledMessageDo) Unscoped() IUnhandledMessageDo {
return u.withDO(u.DO.Unscoped())
}
func (u unhandledMessageDo) Create(values ...*models.UnhandledMessage) error {
if len(values) == 0 {
return nil
}
return u.DO.Create(values)
}
func (u unhandledMessageDo) CreateInBatches(values []*models.UnhandledMessage, batchSize int) error {
return u.DO.CreateInBatches(values, batchSize)
}
// Save : !!! underlying implementation is different with GORM
// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
func (u unhandledMessageDo) Save(values ...*models.UnhandledMessage) error {
if len(values) == 0 {
return nil
}
return u.DO.Save(values)
}
func (u unhandledMessageDo) First() (*models.UnhandledMessage, error) {
if result, err := u.DO.First(); err != nil {
return nil, err
} else {
return result.(*models.UnhandledMessage), nil
}
}
func (u unhandledMessageDo) Take() (*models.UnhandledMessage, error) {
if result, err := u.DO.Take(); err != nil {
return nil, err
} else {
return result.(*models.UnhandledMessage), nil
}
}
func (u unhandledMessageDo) Last() (*models.UnhandledMessage, error) {
if result, err := u.DO.Last(); err != nil {
return nil, err
} else {
return result.(*models.UnhandledMessage), nil
}
}
func (u unhandledMessageDo) Find() ([]*models.UnhandledMessage, error) {
result, err := u.DO.Find()
return result.([]*models.UnhandledMessage), err
}
func (u unhandledMessageDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.UnhandledMessage, err error) {
buf := make([]*models.UnhandledMessage, 0, batchSize)
err = u.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
defer func() { results = append(results, buf...) }()
return fc(tx, batch)
})
return results, err
}
func (u unhandledMessageDo) FindInBatches(result *[]*models.UnhandledMessage, batchSize int, fc func(tx gen.Dao, batch int) error) error {
return u.DO.FindInBatches(result, batchSize, fc)
}
func (u unhandledMessageDo) Attrs(attrs ...field.AssignExpr) IUnhandledMessageDo {
return u.withDO(u.DO.Attrs(attrs...))
}
func (u unhandledMessageDo) Assign(attrs ...field.AssignExpr) IUnhandledMessageDo {
return u.withDO(u.DO.Assign(attrs...))
}
func (u unhandledMessageDo) Joins(fields ...field.RelationField) IUnhandledMessageDo {
for _, _f := range fields {
u = *u.withDO(u.DO.Joins(_f))
}
return &u
}
func (u unhandledMessageDo) Preload(fields ...field.RelationField) IUnhandledMessageDo {
for _, _f := range fields {
u = *u.withDO(u.DO.Preload(_f))
}
return &u
}
func (u unhandledMessageDo) FirstOrInit() (*models.UnhandledMessage, error) {
if result, err := u.DO.FirstOrInit(); err != nil {
return nil, err
} else {
return result.(*models.UnhandledMessage), nil
}
}
func (u unhandledMessageDo) FirstOrCreate() (*models.UnhandledMessage, error) {
if result, err := u.DO.FirstOrCreate(); err != nil {
return nil, err
} else {
return result.(*models.UnhandledMessage), nil
}
}
func (u unhandledMessageDo) FindByPage(offset int, limit int) (result []*models.UnhandledMessage, count int64, err error) {
result, err = u.Offset(offset).Limit(limit).Find()
if err != nil {
return
}
if size := len(result); 0 < limit && 0 < size && size < limit {
count = int64(size + offset)
return
}
count, err = u.Offset(-1).Limit(-1).Count()
return
}
func (u unhandledMessageDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
count, err = u.Count()
if err != nil {
return
}
err = u.Offset(offset).Limit(limit).Scan(result)
return
}
func (u unhandledMessageDo) Scan(result interface{}) (err error) {
return u.DO.Scan(result)
}
func (u unhandledMessageDo) Delete(models ...*models.UnhandledMessage) (result gen.ResultInfo, err error) {
return u.DO.Delete(models)
}
func (u *unhandledMessageDo) withDO(do gen.Dao) *unhandledMessageDo {
u.DO = *do.(*gen.DO)
return u
}

6
storage-new/dbgen/users.gen.go
View file

@ -51,6 +51,7 @@ func newUser(db *gorm.DB, opts ...gen.DOOption) user {
_user.FinishedRegistration = field.NewBool(tableName, "finished_registration")
_user.PrivateKeyRsa = field.NewBytes(tableName, "private_key_rsa")
_user.PrivateKeyEd = field.NewBytes(tableName, "private_key_ed")
_user.RawData = field.NewBytes(tableName, "raw_data")
_user.RemoteInfoId = field.NewField(tableName, "remote_info_id")
_user.RemoteInfo = userHasOneRemoteInfo{
db: db.Session(&gorm.Session{}),
@ -392,6 +393,7 @@ type user struct {
FinishedRegistration field.Bool
PrivateKeyRsa field.Bytes
PrivateKeyEd field.Bytes
RawData field.Bytes
RemoteInfoId field.Field
RemoteInfo userHasOneRemoteInfo
@ -455,6 +457,7 @@ func (u *user) updateTableName(table string) *user {
u.FinishedRegistration = field.NewBool(table, "finished_registration")
u.PrivateKeyRsa = field.NewBytes(table, "private_key_rsa")
u.PrivateKeyEd = field.NewBytes(table, "private_key_ed")
u.RawData = field.NewBytes(table, "raw_data")
u.RemoteInfoId = field.NewField(table, "remote_info_id")
u.fillFieldMap()
@ -472,7 +475,7 @@ func (u *user) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
}
func (u *user) fillFieldMap() {
u.fieldMap = make(map[string]field.Expr, 36)
u.fieldMap = make(map[string]field.Expr, 37)
u.fieldMap["id"] = u.ID
u.fieldMap["username"] = u.Username
u.fieldMap["created_at"] = u.CreatedAt
@ -496,6 +499,7 @@ func (u *user) fillFieldMap() {
u.fieldMap["finished_registration"] = u.FinishedRegistration
u.fieldMap["private_key_rsa"] = u.PrivateKeyRsa
u.fieldMap["private_key_ed"] = u.PrivateKeyEd
u.fieldMap["raw_data"] = u.RawData
u.fieldMap["remote_info_id"] = u.RemoteInfoId
}

1
storage-new/models/0allTypes.go
View file

@ -23,6 +23,7 @@ var AllTypes = []any{
&ServerMetadata{},
&AccessToken{},
&LoginProcessToken{},
&UnhandledMessage{},
&User{},
&UserAuthMethod{},
&UserToBeing{},

2
storage-new/models/ActivityToObject.go
View file

@ -5,4 +5,6 @@ type Activity struct {
Type string // `gorm:"type:activitystreams_activity_type"`
ObjectId string
ObjectType uint32 // Target type: ActivitystreamsActivityTargetType
RawData []byte
}

2
storage-new/models/Note.go
View file

@ -34,6 +34,8 @@ type Note struct {
PingRelations []NoteToPing `gorm:"foreignKey:NoteId;constraint:OnDelete:CASCADE"` // Pings/mentions this note performs
Tags []NoteTag `gorm:"foreignKey:NoteId;constraint:OnDelete:CASCADE"` // Tags this note contains
Edits []NoteEdit `gorm:"foreignKey:NoteId;constraint:OnDelete:CASCADE"` // All edits done to this note
RawData []byte
}
type INote interface {

11
storage-new/models/UnhandledMessage.go Normal file
View file

@ -0,0 +1,11 @@
package models
import "time"
type UnhandledMessage struct {
ID uint64 `gorm:"primarykey"`
CreatedAt time.Time
RawData []byte // Raw data of the message
ForUserId string // Id of the user this message was for
GlobalInbox bool // Whether the message was sent to the global inbox
}

2
storage-new/models/User.go
View file

@ -74,6 +74,8 @@ type User struct {
PrivateKeyRsa []byte
PrivateKeyEd []byte
RawData []byte
// ---- "Remote" linked values
InfoFields []UserInfoField
BeingTypes []UserToBeing

15
web/public/api/activitypub/inbox.go
View file

@ -89,6 +89,9 @@ func userInbox(w http.ResponseWriter, r *http.Request) {
}
log.Debug().Str("object-type", objectType).Msg("Inbox message")
log.Trace().Bytes("body", body).Msg("Inbox raw message")
// TODO: Decide how to handle the handler failing for whatever reason
// Add object to unhandled message table and try again later?
// Discard it? And how would a handler return that it failed?
switch objectType {
case "Like":
handleLike(w, r, data)
@ -103,7 +106,17 @@ func userInbox(w http.ResponseWriter, r *http.Request) {
case "Create":
handleCreate(w, r, data)
default:
log.Warn().Str("object-type", objectType).Msg("Unknown message type")
log.Warn().
Str("object-type", objectType).
Msg("Unknown message type, storing for later processing")
err = dbgen.UnhandledMessage.Create(&models.UnhandledMessage{
ForUserId: userId,
GlobalInbox: false,
RawData: body,
})
if err != nil {
log.Error().Err(err).Msg("Failed to store unhandled message for later")
}
_ = webutils.ProblemDetailsStatusOnly(w, 500)
}
}