You're Invited:Meet the Socket Team at RSAC and BSidesSF 2026, March 23–26.RSVP →
Socket
Book a DemoSign in
Socket
Book a DemoSign in

github.com/gradientzero/comby-store-postgres

Package Overview
Dependencies
Versions
10
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

github.com/gradientzero/comby-store-postgres - go Package Compare versions

Comparing version
v1.0.1
 to
v1.0.2
+37
internal/record.go
package internal
import (
"database/sql"
)
type Command struct {
// system fields
ID sql.NullInt64
// fields
InstanceId int64 `json:"instance_id"`
Uuid string `json:"uuid"`
TenantUuid string `json:"tenant_uuid"`
Domain string `json:"domain"`
CreatedAt int64 `json:"created_at"`
DataType string `json:"data_type"`
DataBytes string `json:"data_bytes"`
ReqCtx string `json:"req_ctx"`
}
type Event struct {
// system fields
ID sql.NullInt64
// fields
InstanceId int64 `json:"instance_id"`
Uuid string `json:"uuid"`
TenantUuid string `json:"tenant_uuid"`
CommandUuid string `json:"command_uuid"`
Domain string `json:"domain"`
AggregateUuid string `json:"aggregate_uuid"`
Version int64 `json:"version"`
CreatedAt int64 `json:"created_at"`
DataType string `json:"data_type"`
DataBytes string `json:"data_bytes"`
}
+133
internal/serializer.go
package internal
import (
"encoding/json"
"github.com/gradientzero/comby/v2"
)
func Serialize(src interface{}) ([]byte, error) {
if comby.IsNil(src) {
return nil, nil
}
dataBytes, err := json.Marshal(src)
if err != nil {
return dataBytes, err
}
return dataBytes, nil
}
func Deserialize(dataBytes []byte, dst interface{}) error {
return json.Unmarshal(dataBytes, dst)
}
// helpers
func BaseEventToDbEvent(evt comby.Event) (*Event, error) {
evtDataBytes, err := Serialize(evt.GetDomainEvt())
if err != nil {
return nil, err
}
dbEvent := &Event{
InstanceId: evt.GetInstanceId(),
Uuid: evt.GetEventUuid(),
TenantUuid: evt.GetTenantUuid(),
CommandUuid: evt.GetCommandUuid(),
Domain: evt.GetDomain(),
AggregateUuid: evt.GetAggregateUuid(),
Version: evt.GetVersion(),
CreatedAt: evt.GetCreatedAt(),
DataType: evt.GetDomainEvtName(),
DataBytes: string(evtDataBytes),
}
return dbEvent, nil
}
func DbEventToBaseEvent(dbEvent *Event) (comby.Event, error) {
// Data of type base.EventData can not be deserialized
// but within the facade the corresponding event data provider
// will take care of this
evt := &comby.BaseEvent{
InstanceId: dbEvent.InstanceId,
EventUuid: dbEvent.Uuid,
TenantUuid: dbEvent.TenantUuid,
CommandUuid: dbEvent.CommandUuid,
Domain: dbEvent.Domain,
AggregateUuid: dbEvent.AggregateUuid,
Version: dbEvent.Version,
CreatedAt: dbEvent.CreatedAt,
DomainEvtName: dbEvent.DataType,
DomainEvtBytes: []byte(dbEvent.DataBytes),
}
return evt, nil
}
func DbEventsToBaseEvents(dbEvents []*Event) ([]comby.Event, error) {
var evts []comby.Event
for _, dbEvent := range dbEvents {
evt, err := DbEventToBaseEvent(dbEvent)
if err != nil {
return nil, err
}
evts = append(evts, evt)
}
return evts, nil
}
func BaseCommandToDbCommand(cmd comby.Command) (*Command, error) {
cmdDataBytes, err := Serialize(cmd.GetDomainCmd())
if err != nil {
return nil, err
}
reqCtxBytes, err := Serialize(cmd.GetReqCtx())
if err != nil {
return nil, err
}
dbCmd := &Command{
InstanceId: cmd.GetInstanceId(),
Uuid: cmd.GetCommandUuid(),
TenantUuid: cmd.GetTenantUuid(),
Domain: cmd.GetDomain(),
CreatedAt: cmd.GetCreatedAt(),
DataType: cmd.GetDomainCmdName(),
DataBytes: string(cmdDataBytes),
ReqCtx: string(reqCtxBytes),
}
return dbCmd, nil
}
func DbCommandToBaseCommand(dbCmd *Command) (comby.Command, error) {
// Data of type base.CommandData can not be deserialized
// but within the facade the corresponding command data provider
// will take care of this
var reqCtx comby.RequestContext
if len(dbCmd.ReqCtx) > 0 {
reqCtxBytes := []byte(dbCmd.ReqCtx)
if err := Deserialize(reqCtxBytes, &reqCtx); err != nil {
return nil, err
}
}
cmd := &comby.BaseCommand{
InstanceId: dbCmd.InstanceId,
CommandUuid: dbCmd.Uuid,
TenantUuid: dbCmd.TenantUuid,
Domain: dbCmd.Domain,
CreatedAt: dbCmd.CreatedAt,
DomainCmdName: dbCmd.DataType,
DomainCmdBytes: []byte(dbCmd.DataBytes),
ReqCtx: &reqCtx,
}
return cmd, nil
}
func DbCommandsToBaseCommands(dbCommands []*Command) ([]comby.Command, error) {
var cmds []comby.Command
for _, dbCommand := range dbCommands {
cmd, err := DbCommandToBaseCommand(dbCommand)
if err != nil {
return nil, err
}
cmds = append(cmds, cmd)
}
return cmds, nil
}
+8
-8
command.store.postgres.go

@@ -8,4 +8,4 @@ package store

"github.com/gradientzero/comby-store-postgres/internal"
"github.com/gradientzero/comby/v2"
combyStore "github.com/gradientzero/comby/v2/store"
_ "github.com/lib/pq"

@@ -136,3 +136,3 @@ )

// sql statement
dbRecord, err := combyStore.BaseCommandToDbCommand(cmd)
dbRecord, err := internal.BaseCommandToDbCommand(cmd)
if err != nil {

@@ -211,3 +211,3 @@ return err

// extract record
var dbRecord combyStore.Command
var dbRecord internal.Command
if err := row.Scan(

@@ -234,3 +234,3 @@ &dbRecord.ID,

// db record to command
cmd, err := combyStore.DbCommandToBaseCommand(&dbRecord)
cmd, err := internal.DbCommandToBaseCommand(&dbRecord)
if err != nil {

@@ -336,5 +336,5 @@ return nil, err

// extract results
var dbRecords []*combyStore.Command
var dbRecords []*internal.Command
for rows.Next() {
var dbRecord combyStore.Command
var dbRecord internal.Command
if err := rows.Scan(

@@ -363,3 +363,3 @@ &dbRecord.ID,

// convert
cmds, err := combyStore.DbCommandsToBaseCommands(dbRecords)
cmds, err := internal.DbCommandsToBaseCommands(dbRecords)
if err != nil {

@@ -392,3 +392,3 @@ return nil, 0, err

// convert to db format
dbRecord, err := combyStore.BaseCommandToDbCommand(cmd)
dbRecord, err := internal.BaseCommandToDbCommand(cmd)
if err != nil {

@@ -395,0 +395,0 @@ return err

+8
-8
event.store.postgres.go

@@ -8,4 +8,4 @@ package store

"github.com/gradientzero/comby-store-postgres/internal"
"github.com/gradientzero/comby/v2"
combyStore "github.com/gradientzero/comby/v2/store"
_ "github.com/lib/pq"

@@ -144,3 +144,3 @@ )

// sql statement
dbRecord, err := combyStore.BaseEventToDbEvent(evt)
dbRecord, err := internal.BaseEventToDbEvent(evt)
if err != nil {

@@ -223,3 +223,3 @@ return err

// extract record
var dbRecord combyStore.Event
var dbRecord internal.Event
if err := row.Scan(

@@ -248,3 +248,3 @@ &dbRecord.ID,

// db record to event
evt, err := combyStore.DbEventToBaseEvent(&dbRecord)
evt, err := internal.DbEventToBaseEvent(&dbRecord)
if err != nil {

@@ -358,5 +358,5 @@ return nil, err

// extract results
var dbRecords []*combyStore.Event
var dbRecords []*internal.Event
for rows.Next() {
var dbRecord combyStore.Event
var dbRecord internal.Event
if err := rows.Scan(

@@ -387,3 +387,3 @@ &dbRecord.ID,

// convert
evts, err := combyStore.DbEventsToBaseEvents(dbRecords)
evts, err := internal.DbEventsToBaseEvents(dbRecords)
if err != nil {

@@ -417,3 +417,3 @@ return nil, 0, err

// convert to db format
dbRecord, err := combyStore.BaseEventToDbEvent(evt)
dbRecord, err := internal.BaseEventToDbEvent(evt)
if err != nil {

@@ -420,0 +420,0 @@ return err