store

type Database struct {
	// ID corresponds to the types.Database ID
	ID string
	// Name corresponds to the types.Database Name
	Name string
	// CreatedAt corresponds to the types.Database CreatedAt
	CreatedAt time.Time
	// UpdatedAt corresponds to the types.Database UpdatedAt
	UpdatedAt time.Time
}

type DatabaseStore interface {
	// Get a Database by ID
	Get(ctx context.Context, databaseID string) (*types.Database, error)
	// List databases
	List(ctx context.Context) (*types.DatabaseList, error)
	// Create a database
	Create(ctx context.Context, database *types.Database) (*types.Database, error)
	// Delete a database
	Delete(ctx context.Context, databaseID string) error
}

type Factory interface {
	Get() (*gorm.DB, error)
}

type Field struct {

	// ID stores the types.FieldDefinition ID
	ID string

	// DatabaseID stores the types.FieldDefinition DatabaseID
	DatabaseID string

	// FormID stores the types.FieldDefinition FormID
	FormID string

	// RootFormID stores the root form definition ID for this field.
	// See comment on Form.RootOwnerID
	RootFormID string

	// RootForm is the gorm hack to create a foreign key
	RootForm *Form

	// Name stores the types.FieldDefinition Name
	Name string

	// Description stores the types.FieldDefinition Description
	Description string

	// Code stores the types.FieldDefinition Code
	Code string

	// Key stores the types.FieldDefinition Key
	Key bool

	// Required stores the types.FieldDefinition Required
	Required bool

	// SubFormID stores the SubForm ID. This should be equal to the Field.ID.
	// Merely keeping a duplicate value so we can have a foreign key
	SubFormID *string

	// SubForm creates a gorm ForeignKey
	SubForm *Form

	// ReferencedDatabaseID stores the referenced DatabaseID when the field is a Reference field
	ReferencedDatabaseID *string

	// ReferencedDatabase allows gorm to create a foreign key
	ReferencedDatabase *Database

	// ReferencedFormID stores the referenced FormID when the field is a Reference field
	ReferencedFormID *string

	// ReferencedForm allows gorm to create a foreign key
	ReferencedForm *Form

	// Type stores the field type
	Type types.FieldKind

	// CreatedAt stores the time the Field was created
	CreatedAt time.Time

	// UpdatedAt stores the time the field was updated
	UpdatedAt time.Time
}

type Fields []*Field

type FlatForms struct {
	Fields  Fields
	Forms   Forms
	Options Options
}

type Folder struct {
	ID         string
	DatabaseID string
	Database   Database
	ParentID   *string
	Parent     *Folder `gorm:"constraint:OnUpdate:CASCADE,OnDelete:CASCADE;"`
	Name       string
	CreatedAt  time.Time
	UpdatedAt  time.Time
}

type FolderStore interface {
	// Get a folder
	Get(ctx context.Context, folderID string) (*types.Folder, error)
	// List folders
	List(ctx context.Context) (*types.FolderList, error)
	// Create a folder
	Create(ctx context.Context, folder *types.Folder) (*types.Folder, error)
	// Delete a folder
	Delete(ctx context.Context, id string) error
}

type Form struct {

	// ID stores the types.FormDefinition ID
	ID string `gorm:"index:idx_form_id_database_id,unique"`

	// DatabaseID stores the types.FormDefinition DatabaseID
	DatabaseID string `gorm:"index:idx_form_id_database_id,unique"`

	// Database is used so that gorm creates a (not nullable) Foreign Key on the Database table
	Database Database

	// RootOwnerID is present because when we want to fetch the root form and all SubForms
	// for a given FormDefinition, we can simply query WHERE root_owner_id = <RootFormID>.
	// This will retrieve all the forms, subforms and nested subforms that are part
	// of the same FormDefinition
	RootOwnerID string

	// RootOwner is the gorm hack to create a (not nullable) Foreign Key on the Form table
	RootOwner *Form

	// OwnerID represents a SubForm owner OR, when the form is the root form (FormDefinition)
	// then the OwnerID == ID. It's nice like this because we can query all root FormDefinitions
	// with a query like "SELECT * FROM forms where id == owner_id"
	OwnerID string

	// Owner is the same gorm hack to create a (not nullable) foreign key on the Form table
	Owner *Form

	// FolderID stores the types.FormDefinition FolderID
	FolderID *string

	// Folder is the gorm hack to create a (nullable) foreign key on the Folder table
	Folder *Folder

	// Name stores the types.FormDefinition Name
	Name string

	// Type stores the types.FormDefinition Type
	Type string

	// CreatedAt represents when this form was created
	CreatedAt time.Time

	// UpdatedAt represents when this form was updated
	UpdatedAt time.Time
}

type FormStore interface {
	// Get a single Form Definition
	Get(ctx context.Context, formID string) (*types.FormDefinition, error)
	// List FormDefinitions
	List(ctx context.Context) (*types.FormDefinitionList, error)
	// Create a FormDefinition
	Create(ctx context.Context, form *types.FormDefinition) (*types.FormDefinition, error)
	// Delete a FormDefinition
	Delete(ctx context.Context, id string) error
}

type Forms []*Form

type IdentityProvider struct {

	// ID is the Identity provider ID
	ID string

	// OrganizationID is the OrganizationID that owns this IdentityProvider
	OrganizationID string

	// Organization is the Organization that owns this IdentityProvider.
	// We include this field here because gorm.DB creates the Foreign Key
	// constraints when this field is present.
	Organization Organization

	// Domain represents the OIDC Issuer for this Identity Provider
	Domain string

	// ClientID represents the OAuth2 ClientID for this IdentityProvider
	// For example, an Okta ClientID
	ClientID string

	// ClientSecret represents the OAuth2 ClientSecret for the IdentityProvider
	// For example, an Okta ClientSecret
	ClientSecret string

	// EmailDomain represents the Domain of email addresses that should be
	// using this identity provider.
	// e.g. if EmailDomain = "my-org.com", then johndoe@my-org.com would use
	// this IdentityProvider
	EmailDomain string

	// Name of this IdentityProvider
	Name string
}

type IdentityProviderCreateOptions struct {
	// ReturnClientSecret will include the IdentityProvider.ClientSecret in the response
	ReturnClientSecret bool
}

type IdentityProviderGetOptions struct {
	// ReturnClientSecret will include the IdentityProvider.ClientSecret in the response
	ReturnClientSecret bool
}

type IdentityProviderListOptions struct {
	// ReturnClientSecret will include the IdentityProvider.ClientSecret in the response
	ReturnClientSecret bool
}

type IdentityProviderStore interface {
	// List identity providers
	List(ctx context.Context, organizationID string, options IdentityProviderListOptions) ([]*types.IdentityProvider, error)
	// Get an IdentityProvider
	Get(ctx context.Context, identityProviderId string, options IdentityProviderGetOptions) (*types.IdentityProvider, error)
	// FindForEmailDomain finds IdentityProviders for the given email domain. Should only return one because we should not allow two
	// identityProvider to use the same email domain
	// TODO make this method return a single IdentityProvider
	FindForEmailDomain(ctx context.Context, emailDomain string, options IdentityProviderListOptions) ([]*types.IdentityProvider, error)
	// Create an IdentityProvider
	Create(ctx context.Context, identityProvider *types.IdentityProvider, options IdentityProviderCreateOptions) (*types.IdentityProvider, error)
	// Update an IdentityProvider
	Update(ctx context.Context, identityProvider *types.IdentityProvider, options IdentityProviderUpdateOptions) (*types.IdentityProvider, error)
}

type IdentityProviderUpdateOptions struct {
	// ReturnClientSecret will include the IdentityProvider.ClientSecret in the response
	ReturnClientSecret bool
}

type IdentityProviders []*IdentityProvider

type Option struct {

	// ID stores the types.SelectOption ID
	ID string `gorm:"primarykey"`

	// DatabaseID stores the Form's DatabaseID
	DatabaseID string

	// RootFormID stores the root FormID. See Form.RootOwnerID
	RootFormID string

	// FormID stores the FormID of the single/multi select field
	FormID string

	// FieldID stores the single/multi select Field.ID
	FieldID string

	// Name stores the types.SelectOption Name
	Name string
}

type Options []*Option

type Organization struct {
	ID          string
	Name        string
	EmailDomain string
}

type OrganizationStore interface {
	Get(ctx context.Context, id string) (*types.Organization, error)
	Create(ctx context.Context, organiztion *types.Organization) (*types.Organization, error)
	Update(ctx context.Context, organization *types.Organization) (*types.Organization, error)
	List(ctx context.Context) ([]*types.Organization, error)
}

type Permission string

type RecordStore interface {
	Get(ctx context.Context, recordRef types.RecordRef) (*types.Record, error)
	List(ctx context.Context, options types.RecordListOptions) (*types.RecordList, error)
	Create(ctx context.Context, record *types.Record) (*types.Record, error)
	Update(ctx context.Context, record *types.Record) (*types.Record, error)
	Delete(ctx context.Context, recordRef types.RecordRef) error
}