mdlsub

type DelayOpError struct {
	Err error
}

type FetchData struct {
	Data json.RawMessage `json:"data"`
}

type FixtureSet struct {
	// contains filtered or unexported fields
}

type FixtureSettings struct {
	Dataset FixtureSettingsDataset `cfg:"dataset"`
	Host    string                 `cfg:"host"`
	Path    string                 `cfg:"path"`
}

type FixtureSettingsDataset struct {
	Id int `cfg:"id"`
}

type Model interface {
	GetId() any
}

type ModelDb struct {
	Id *uint `gorm:"primary_key;"`
}

type ModelSpecification struct {
	CrudType string
	Version  int
	ModelId  string
}

type ModelTransformer interface {
	GetModel() (any, error)
	// contains filtered or unexported methods
}

type ModelTransformers map[string]VersionedModelTransformers

type Output interface {
	Persist(ctx context.Context, model Model, op string) error
}

type OutputDb struct {
	// contains filtered or unexported fields
}

type OutputDdb struct {
	// contains filtered or unexported fields
}

type OutputFactory func(ctx context.Context, config cfg.Config, logger log.Logger, settings *SubscriberSettings, transformers VersionedModelTransformers) (map[int]Output, error)

type OutputKvstore struct {
	// contains filtered or unexported fields
}

type Outputs map[string]map[int]Output

type Publisher interface {
	PublishBatch(ctx context.Context, typ string, version int, values []any, customAttributes ...map[string]string) error
	Publish(ctx context.Context, typ string, version int, value any, customAttributes ...map[string]string) error
}

type PublisherSettings struct {
	mdl.ModelId
	Producer   string `cfg:"producer" validate:"required_without=OutputType"`
	OutputType string `cfg:"output_type" validate:"required_without=Producer"`
	Shared     bool   `cfg:"shared"`
}

type Settings struct {
	Subscribers map[string]*SubscriberSettings `cfg:"subscribers"`
}

type SubscriberCallback struct {
	// contains filtered or unexported fields
}

type SubscriberCore interface {
	GetModelIds() []string
	GetLatestModelIdVersion(modelId mdl.ModelId) (int, error)
	GetTransformer(spec *ModelSpecification) (ModelTransformer, error)
	GetTransformersForModel(modelId mdl.ModelId) (VersionedModelTransformers, error)
	GetOutput(spec *ModelSpecification) (Output, error)
	Persist(ctx context.Context, spec *ModelSpecification, model Model) error
	Transform(ctx context.Context, spec *ModelSpecification, input any) (Model, error)
}

type SubscriberInputConfigPostProcessor func(config cfg.GosoConf, name string, subscriberSettings *SubscriberSettings) cfg.Option

type SubscriberModel struct {
	mdl.ModelId
	Shared bool `cfg:"shared"`
}

type SubscriberOutputConfigPostProcessor func(config cfg.GosoConf, name string, subscriberSettings *SubscriberSettings) cfg.Option

type SubscriberSettings struct {
	Input            string          `cfg:"input" default:"sns"`
	Output           string          `cfg:"output"`
	PersistGraceTime time.Duration   `cfg:"persist_grace_time" default:"10s" validate:"min=0"`
	RunnerCount      int             `cfg:"runner_count" default:"10" validate:"min=1"`
	SourceModel      SubscriberModel `cfg:"source"`
	TargetModel      SubscriberModel `cfg:"target"`
}

type TransformerFactory func(ctx context.Context, config cfg.Config, logger log.Logger) (ModelTransformer, error)

type TransformerMapTypeVersionFactories map[string]TransformerMapVersionFactories

type TransformerMapVersionFactories map[int]TransformerFactory

type TypedTransformer[I any, M Model] interface {
	// Transform converts the input into an output model. If Transform returns nil as the output, we don't persist the value.
	Transform(ctx context.Context, inp I) (out *M, err error)
}

type TypedTransformerFactory[I any, M Model] func(ctx context.Context, config cfg.Config, logger log.Logger) (TypedTransformer[I, M], error)

type UnknownModelError struct {
	ModelId string
}

type UnknownModelVersionError struct {
	ModelId string
	Version int
}

type VersionedModelTransformers map[int]ModelTransformer