config

type CommitKind string

type CommitORM struct {
	util.ImmutableEmbed `json:",inline"`
	CommitObject        `json:"commit_object"`
}

type CommitObject struct {
	CommitKind       CommitKind        `json:"commit_kind"`
	ConfigDataObject *ConfigDataObject `json:"data_object"`
}

type ConfigContextHandle interface {
	SetData(ctx context.Context, tx *gorm.DB, cdo *ConfigDataObject, data util.Data) error
}

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

type ConfigDagNode interface {
	GetConfigDagNode() *ConfigDagNodeEmbed
}

type ConfigDagNodeEmbed struct {
	AccountId       util.AccountId       `json:"account_id" gorm:"index;not null"`
	UserId          *util.UserId         `json:"user_id" gorm:"index;null"`
	ConfigVersionId util.ConfigVersionId `json:"config_version_id" gorm:"id;primaryKey"`

	// Git like DAG
	NodeKind   ConfigDagNodeKind       `json:"node_kind"`
	Hash       util.ConfigVersionHash  `json:"config_version_hash"`
	ParentId   *util.ConfigVersionId   `json:"parent_id"`
	ParentHash *util.ConfigVersionHash `json:"parent_hash"`

	Note string `json:"note"`

	// AdditionalParents []ParentRef             `json:"additional_parents"`
	Data *ConfigDataObject `json:"data" gorm:"type:jsonb"`
}

type ConfigDagNodeKind string

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

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

type ConfigDataObjectEmbed struct {
	// ConfigDataObject `json:",inline" gorm:"config_data_object;type:jsonb;not null"`
	ConfigDataObject ConfigDataObject `json:",inline" gorm:"embedded"`
}

type ConfigDataRecord util.Data

type ConfigDiffParams struct {
	From *ConfigDiffSpec
	To   *ConfigDiffSpec

	IncludeObject              bool
	IncludePreviousObject      bool
	IncludeNodeContentsPatch   bool
	IncludeRecordMetadataPatch bool
	IncludeRecordContentsPatch bool

	IncludeRecord bool

	OnlyMatching bool

	// RecordMatchFilter *RecordMatchFilter
	ConfigRecordQuery *ConfigRecordQuery

	OnlyLatest bool
}

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

type ConfigDiffSpec struct {
	Version *ConfigVersionRef `json:"version"`
}

type ConfigDiffVersion struct {
	FromVersion *ConfigVersionRef `json:"from_version"`
	ToVersion   *ConfigVersionRef `json:"to_version"`
	Match       bool              `json:"match"`

	NodeContents   *util.Data            `json:"object,omitempty"`
	RecordMetadata *ConfigRecordMetadata `json:"record_metadata,omitempty"`
	RecordContents *util.Data            `json:"record_contents,omitempty"`
	RecordHistory  []*ConfigDiffVersionHistoryEntry

	NodeContentsPatch   *jsondiff.Patch `json:"diff"`
	RecordMetadataPatch *jsondiff.Patch `json:"record_metadata_diff"`
	RecordContentsPatch *jsondiff.Patch `json:"record_diff"`

	// Temporary
	PrevObject *util.Data `json:"prev_object,omitempty"`
}

type ConfigDiffVersionHistoryEntry struct {
	RecordContents       *util.Data                `json:"record_contents"`
	RecordCollectionKey  *util.ConfigCollectionKey `json:"record_collection_key"`
	RecordItemKey        *util.ConfigItemKey       `json:"record_item_key"`
	ConfigRecordMetadata *ConfigRecordMetadata     `json:"config_record_metadata"`
	NodeMetadata         *ConfigNodeMetadata       `json:"node_metadata"`
	// ConfigVersionHash       *util.ConfigVersionHash   `json:"config_version_hash"`
	RecordContentsPatch     *jsondiff.Patch `json:"record_diff"`
	RecordContentsTextPatch string          `json:"record_diff_text"`
}

type ConfigDiffVersions struct {
	FromVersion *ConfigVersionRef          `json:"from_version"`
	ToVersion   *ConfigVersionRef          `json:"to_version"`
	Versions    []ConfigDiffVersion        `json:"versions"`
	ListHash    *util.ConfigSchemaListHash `json:"list_hash"`
}

type ConfigDocumentORM struct {
	ConfigDocumentKey util.ConfigDocumentKey `json:"config_document_key" gorm:"type:text;not null"`
	ConfigDocumentId  util.ConfigDocumentId  `json:"config_document_id" gorm:"type:text;not null"`

	// ConfigImmutableDataEmbed `json:",inline" gorm:"embedded"`
	// ConfigImmutableDataEmbed `json:",inline" gorm:"-"`
	// ConfigImmutableDataEmbed `json:",inline" ` //gorm:"-"`
	ConfigImmutableDataEmbed `json:",inline"`
}

type ConfigDocumentRecord util.Data

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

type ConfigImmutableDataEmbed struct {
	AccountId util.AccountId `json:"account_id" gorm:"not null"`
	UserId    *util.UserId   `json:"user_id" gorm:""`
	CreatedAt time.Time      `json:"created_at"`
	CreatedBy *util.UserId   `json:"created_by" gorm:""`
	DeletedAt *time.Time     `json:"deleted_at"`

	// ConfigImmutableEmbedOld `json:",inline" gorm:"embedded"`
	// ConfigDataObject `json:",inline" gorm:"config_data_object;type:jsonb"`
	// ConfigDataObject `json:",inline" gorm:"config_data_object"`
	// ConfigDataObject `json:",inline" gorm:"-"`
	// ConfigDataObject `json:",inline" gorm:"embedded;type:jsonb"`
	// ConfigDataObject `json:",inline"`
	ConfigDataObjectEmbed `json:",inline"`
}

type ConfigKeyedDataORM struct {
	ConfigKey util.ConfigKey `json:"config_key" gorm:"type:text;not null"`

	ConfigImmutableDataEmbed `json:",inline"`
}

type ConfigKeyedRecord util.Data

type ConfigKeyedRecordObject struct {
	ConfigRecordObject
}

type ConfigListEntry struct {
	RecordKey           *util.ConfigRecordKey            `json:"id"`
	RecordKind          *ConfigRecordKind                `json:"record_kind"`
	RecordId            *util.ConfigRecordId             `json:"record_id"`
	RecordCollectionKey *util.ConfigCollectionKey        `json:"record_collection_key"`
	RecordItemKey       *util.ConfigItemKey              `json:"record_item_key"`
	NodeMetadata        *ConfigNodeMetadata              `json:"node_metadata"`
	RecordContents      *util.Data                       `json:"record_contents"`
	RecordHistory       []*ConfigDiffVersionHistoryEntry `json:"record_history"`
}

type ConfigMetadata struct {
	CreatedAt time.Time `json:"created_at"`
	// TODO: Make this non-optional and always pass the user id
	// use ScopeKind to determine if it's an account or user scope
	CreatedBy *util.UserId `json:"created_by"`

	VersionRef ConfigVersionRef  `json:"version_ref"`
	ParentRef  *ConfigVersionRef `json:"parent_ref"`
}

type ConfigModelFunc func() ConfigRecordModel

type ConfigNode struct {
	NodeMetadata ConfigNodeMetadata `json:"node_metadata" gorm:"column:node_metadata;type:jsonb;not null"`
	Contents     *util.Data         `json:"node_contents" gorm:"column:node_contents;type:jsonb"`
}

type ConfigNodeKind string

type ConfigNodeMetadata struct {
	NodeKind    ConfigNodeKind    `json:"node_kind" gorm:"type:text;not null"`
	Scope       util.ScopeKind    `json:"scope" gorm:"type:text;not null"`
	AccountId   util.AccountId    `json:"account_id" gorm:"type:text;not null"`
	UserId      util.UserId       `json:"user_id" gorm:"type:text"`
	CreatedAt   time.Time         `json:"created_at" gorm:"type:timestamp with time zone;not null"`
	CreatedBy   util.UserId       `json:"created_by" gorm:"type:text"`
	CommittedAt *time.Time        `json:"committed_at" gorm:"index;type:timestamp with time zone"`
	CommittedBy *util.UserId      `json:"committed_by" gorm:"index;type:text"`
	VersionRef  ConfigVersionRef  `json:"version_ref" gorm:"type:jsonb;not null"`
	ParentRef   *ConfigVersionRef `json:"parent_ref" gorm:"type:jsonb"`
}

type ConfigNodeORM struct {
	util.ImmutableEmbed `json:",inline"`
	ConfigNode
}

type ConfigORM struct {
	Id        string         `json:"id" gorm:"primaryKey"`
	AccountId util.AccountId `json:"account_id" gorm:"index;not null"`
	CreatedAt time.Time      `json:"created_at"`
	UpdatedAt time.Time      `json:"updated_at"`
	DeletedAt *time.Time     `json:"deleted_at"`
	CreatedBy *util.UserId   `json:"created_by" gorm:"index"`
}

type ConfigQuerier interface {
	Where(cond interface{}, params ...interface{}) ConfigQuerier
}

type ConfigQueryFunc func(querier ConfigQuerier) ConfigQuerier

type ConfigQueryValues map[string]interface{}

type ConfigRecordKind string

type ConfigRecordMetadata struct {
	RecordId      util.ConfigRecordId      `json:"record_id"`
	CollectionKey util.ConfigCollectionKey `json:"record_collection_key"`
	ItemKey       *util.ConfigItemKey      `json:"record_item_key"`
	RecordKind    *ConfigRecordKind        `json:"record_kind"`
}

type ConfigRecordModel interface {
	// Gorm methods
	TableName() string

	GetConfigDataObject() *ConfigDataObject
}

type ConfigRecordNode struct {
	RecordMetadata ConfigRecordMetadata `json:"record_metadata" gorm:"column:record_metadata;type:jsonb;not null"`
	RecordContents util.Data            `json:"record_contents" gorm:"column:record_contents;type:jsonb"`
}

type ConfigRecordORM struct {
	util.ImmutableEmbed `json:",inline"`
	ConfigRecordObject  `json:"config_record_object"`
}

type ConfigRecordObject struct {
	ConfigRecordKind ConfigRecordKind `json:"record_kind"`

	RecordMetadata ConfigRecordMetadata `json:"record_metadata" gorm:"column:record_metadata;type:jsonb;not null"`
	Contents       util.Data            `json:"record_contents" gorm:"column:record_contents;type:jsonb"`
}

type ConfigRecordQuery struct {
	Scope             *util.ScopeKind           `json:"scope_kind"`
	AccountId         *util.AccountId           `json:"account_id"`
	UserId            *util.UserId              `json:"user_id"`
	RecordKind        *ConfigRecordKind         `json:"record_kind"`
	RecordId          *util.ConfigRecordId      `json:"record_id"`
	CollectionKey     *util.ConfigCollectionKey `json:"collection_key"`
	ItemKey           *util.ConfigItemKey       `json:"item_key"`
	ConfigVersionHash *util.ConfigVersionHash   `json:"config_version_hash"`
}

type ConfigReferenceKind string

type ConfigReferenceORM struct {
	Scope     util.ScopeKind `json:"scope" gorm:"uniqueIndex:ref_unique;not null"`
	AccountId util.AccountId `json:"account_id" gorm:"uniqueIndex:ref_unique;not null"`
	UserId    *util.UserId   `json:"user_id" gorm:"uniqueIndex:ref_unique"`

	ConfigReferenceKind ConfigReferenceKind `json:"reference_kind" gorm:"uniqueIndex:ref_unique;not null"`

	VersionRef *ConfigVersionRef `json:"version_ref" gorm:"type:jsonb;not null"`
}

type ConfigReferenceResult struct {
	CurrentRef *ConfigVersionRef `json:"current_ref"`
	ParentRef  *ConfigVersionRef `json:"parent_ref"`
}

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

type ConfigResourceData map[string]interface{}

type ConfigSchemaAssociationRecord struct {
	SchemaHash    *util.ConfigSchemaHash    `json:"schema_hash" gorm:"column:schema_hash;type:varchar(64);not null"`
	SchemaIdValue *util.ConfigSchemaIdValue `json:"schema_id_value" gorm:"column:schema_id_value;type:varchar(64);not null"`
	SchemaRef     *ConfigVersionRef         `json:"schema_ref" gorm:"column:schema_ref;type:jsonb;not null"`
}

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

type ConfigSchemaObject struct {
	SchemaName     *util.ConfigSchemaName     `json:"schema_name"`
	SchemaIdValue  *util.ConfigSchemaIdValue  `json:"schema_id_value"`
	SchemaContents *util.ConfigSchemaContents `json:"schema_contents"`
}

type ConfigSchemaRecord struct {
	SchemaHash     *util.ConfigVersionHash   `json:"schema_hash" gorm:"column:schema_hash;type:varchar(64);not null"`
	SchemaName     *util.ConfigSchemaName    `json:"schema_name" gorm:"column:schema_name;type:varchar(64);not null"`
	SchemaIdValue  *util.ConfigSchemaIdValue `json:"schema_id_value" gorm:"column:schema_id_value;type:varchar(64);not null"`
	SchemaContents util.ConfigSchemaContents `json:"schema_contents" gorm:"column:schema_contents;type:jsonb"`
}

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

type ConfigSchemaVersions struct {
	Versions []*ConfigSchemaRecord `json:"versions"`
	ListHash string                `json:"list_hash"`
}

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

type ConfigSettingHandle ConfigContextHandle

type ConfigStageAudienceKind string

type ConfigStageKind string

type ConfigTagORM struct {
	ConfigTagObject `json:",inline" gorm:"embedded"`
}

type ConfigTagObject struct {
	AccountId util.AccountId `json:"account_id" gorm:"uniqueIndex:config_tag_object_tag;not null"`
	UserId    *util.UserId   `json:"user_id" gorm:"uniqueIndex:config_tag_object_tag;null"`

	Tag        string            `json:"tag" gorm:"uniqueIndex:config_tag_object_tag;not null"`
	VersionRef *ConfigVersionRef `json:"version_ref"`

	ConfigReferenceKind     *ConfigReferenceKind     `json:"config_reference_kind" gorm:"index"`
	ConfigStageAudienceKind *ConfigStageAudienceKind `json:"config_stage_audience_kind" gorm:"index"`
	ConfigStageKind         *ConfigStageKind         `json:"config_stage_kind" gorm:"index"`
}

type ConfigVersionORM struct {
	Id util.ConfigVersionId `json:"id"`

	ConfigDagNodeEmbed `json:",inline" gorm:"embedded"`
}

type ConfigVersionRef struct {
	Scope             util.ScopeKind         `json:"scope" gorm:"index;not null"`
	AccountId         util.AccountId         `json:"account_id" gorm:"index;not null"`
	UserId            *util.UserId           `json:"user_id" gorm:"index;null"`
	ConfigVersionId   util.ConfigVersionId   `json:"config_version_id" gorm:"index;not null"`
	ConfigVersionHash util.ConfigVersionHash `json:"config_version_hash" gorm:"index;not null"`
	CreatedAt         time.Time              `json:"created_at"`
	CreatedBy         util.UserId            `json:"created_by" gorm:"index;null"`
	CommittedAt       *time.Time             `json:"committed_at"`
	CommittedBy       *util.UserId           `json:"committed_by" gorm:"index;null"`
	Note              *string                `json:"note"`
}

type ConfigVersions struct {
	Versions []*ConfigRecordObject `json:"versions"`
	ListHash string                `json:"list_hash"`
}

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

type DiffVersionChainEntry struct {
	CurrentHash    *util.ConfigVersionHash          `json:"cur_hash"`
	ParentHash     *util.ConfigVersionHash          `json:"parent_hash"`
	NodeKind       *ConfigNodeKind                  `json:"node_kind"`
	NodeMetadata   *ConfigNodeMetadata              `json:"node_metadata"`
	NodeContents   *util.Data                       `json:"node_contents"`
	RecordMetadata *ConfigRecordMetadata            `json:"record_metadata"`
	RecordContents *util.Data                       `json:"record_contents"`
	RecordHistory  []*ConfigDiffVersionHistoryEntry `json:"record_history"`
	RecordMatch    bool                             `json:"record_match"`
}

type ErrConfigDataObjectEncodingFailed struct {
	Err error `json:"error"`
}

type ErrConfigObjectSettingConflict struct {
	Err error `json:"error"`
}

type ErrConfigSettingError struct {
	Err error `json:"error"`
}

type ErrConfigSettingHandleConsumed struct{}

type ErrInvalidConfigDataObjectHandle struct {
	Err error `json:"error"`
}

type ErrInvalidConfigDiffParams struct {
	Err error `json:"error"`
}

type ErrInvalidConfigRecordType struct {
	Err error `json:"error"`
}

type ErrInvalidConfigSettingHandle struct {
	Err error `json:"error"`
}

type ErrMissingRequiredParameter struct {
	ParamName string `json:"param_name"`
}

type ErrReferenceNotFound struct {
	Scope         util.ScopeKind      `json:"scope"`
	AccountId     util.AccountId      `json:"account_id"`
	UserId        *util.UserId        `json:"user_id"`
	ReferenceKind ConfigReferenceKind `json:"reference_kind"`
}

type RecordMatchFilter struct {
	Scope               *util.ScopeKind           `json:"scope"`
	AccountId           *util.AccountId           `json:"account_id"`
	UserId              *util.UserId              `json:"user_id"`
	RecordKind          *ConfigRecordKind         `json:"record_kind"`
	RecordId            *util.ConfigRecordId      `json:"record_id"`
	RecordCollectionKey *util.ConfigCollectionKey `json:"record_collection_key"`
	RecordItemKey       *util.ConfigItemKey       `json:"record_item_key"`
	OnlyMatching        bool                      `json:"only_matching"`
}

type RefMap map[ConfigReferenceKind]ConfigReferenceORM

type SetRecordValuesResult struct {
	NodeMetadata ConfigNodeMetadata `json:"node_metadata"`
	NodeContents *util.Data         `json:"node_contents"`
}

type ValueSettingMode string