ent

type ActionConfig ¶

type ActionConfig struct {
	// Action type
	Action ActionOperation
	Fields []string // restrict the fields that can be mutated in this action to the following fields
	//	MutationOnlyFields  // TODO v2  map[string]{Type of some sort} e.g. ConfirmPassword string
	CustomActionName string // override default generated Go name
	// Flag to hide action(s) from GraphQL
	HideFromGraphQL bool
	// override default graphql name generated
	CustomGraphQLName string
}

ActionConfig provides a way to configure the actions generated for the ent

type ActionOperation ¶

type ActionOperation uint

ActionOperation is a named type that represents the different actions to be generated.

const (
	// CreateAction generates a create action for the ent. If no fields are provided, uses all fields
	// on the ent. Doesn't include private fields if no fields are provided.
	CreateAction ActionOperation = 1 << iota
	// EditAction generates an edit action for the ent. If no fields are provided, uses all fields
	// on the ent. Can have multiple EditActions with different fields provided. Doesn't include
	// private fields if no fields are provided.
	EditAction
	// DeleteAction generates a delete action for the ent.
	DeleteAction
	// MutationsAction is a shortcut to generate create, edit, and delete actions for an ent
	// Can be used to boostrap ents or for simple ents where the granularity of actions is overkill
	// Provides CUD	of CRUD. Can be the default for most ents. Should rarely be used for the `User` or `Account` ent
	MutationsAction
	// AddEdgeAction is used to provide the ability to add an edge in an AssociationEdge.
	AddEdgeAction
	// RemoveEdgeAction is used to provide the ability to remove an edge in an AssociationEdge.
	RemoveEdgeAction
	// EdgeGroupAction is used to provide the abilith to edit an edge group in an AssociationEdgeGroup.
	EdgeGroupAction
)

type AssocEdge ¶

type AssocEdge struct {
	ID1      string         `db:"id1"`
	ID1Type  NodeType       `db:"id1_type"`
	EdgeType EdgeType       `db:"edge_type"`
	ID2      string         `db:"id2"`
	ID2Type  NodeType       `db:"id2_type"`
	Time     time.Time      `db:"time"`
	Data     sql.NullString `db:"data"`
}

AssocEdge is the information about an edge between two Nodes It's generic enough so that it applies across all types. Doesn't care what table it's stored in.

func LoadEdgeByType(id string, id2 string, edgeType EdgeType) (*AssocEdge, error)

func LoadEdgesByType(id string, edgeType EdgeType, options ...func(*LoadEdgeConfig)) ([]*AssocEdge, error)

func LoadUniqueEdgeByType(id string, edgeType EdgeType) (*AssocEdge, error)

func (edge *AssocEdge) DBFields() DBFields

func (edge *AssocEdge) GetID() string

type AssocEdgeConfig ¶

type AssocEdgeConfig struct {
	EdgeType        string `db:"edge_type"`
	EdgeName        string `db:"edge_type"`
	SymmetricEdge   bool   `db:"symmetric_edge"`
	InverseEdgeType string `db:"inverse_edge_type"`
	EdgeTable       string `db:"edge_table"`
}

AssocEdgeConfig is configuration used to configure edges in the ent-framework

func (config *AssocEdgeConfig) GetTableName() string

type AssocEdgeData ¶

type AssocEdgeData struct {
	EdgeType        EdgeType       `db:"edge_type" pkey:"true"` // if you have a pkey, don't add id uuid since we already have one...
	EdgeName        string         `db:"edge_name"`
	SymmetricEdge   bool           `db:"symmetric_edge"`
	InverseEdgeType sql.NullString `db:"inverse_edge_type"`
	EdgeTable       string         `db:"edge_table"`
	Timestamps
}

AssocEdgeData is corresponding ent for AssocEdgeConfig

func GetEdgeInfo(edgeType EdgeType, tx *sqlx.Tx) (*AssocEdgeData, error)

func (edgeData *AssocEdgeData) DBFields() DBFields

func (edgeData *AssocEdgeData) GetConfig() Config

func (edgeData *AssocEdgeData) GetID() string

func (edgeData *AssocEdgeData) GetPrimaryKey() string

func (edgeData *AssocEdgeData) GetPrivacyPolicy() PrivacyPolicy

func (edgeData *AssocEdgeData) GetType() NodeType

func (edgeData *AssocEdgeData) GetViewer() viewer.ViewerContext

type AssocEdgeDataResult ¶

type AssocEdgeDataResult struct {
	EdgeData *AssocEdgeData
	Err      error
}

AssocEdgeDataResult stores the result of loading AssocEdgeData

func (res *AssocEdgeDataResult) Error() string

type AssocEdgeDatasResult ¶

type AssocEdgeDatasResult struct {
	Edges []*AssocEdgeData
	Err   error
}

AssocEdgeDatasResult stores the result of loading all assoc edges concurrently

func (res *AssocEdgeDatasResult) Error() string

type AssocEdgeLoader ¶

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

AssocEdgeLoader is used to load AssocEdgeData. implements Loader interface

func (res *AssocEdgeLoader) GetConfig() Config

func (res *AssocEdgeLoader) GetMap() map[EdgeType]*AssocEdgeData

func (res *AssocEdgeLoader) GetNewInstance() DBObject

func (res *AssocEdgeLoader) GetPrimaryKey() string

type AssocEdgeMap ¶

type AssocEdgeMap map[string]*AssociationEdge

AssocEdgeMap is a mapping of name of edge to EdgeType

type AssocEdgeResult ¶

type AssocEdgeResult struct {
	Edge *AssocEdge
	Err  error
}

AssocEdgeResult stores the result of loading an Edge concurrently

func (res *AssocEdgeResult) Error() string

type AssocEdgesResult ¶

type AssocEdgesResult struct {
	Edges []*AssocEdge
	Err   error
}

AssocEdgesResult stores the result of loading a slice of edges concurrently

func (res *AssocEdgesResult) Error() string

type AssocStatusMap ¶

type AssocStatusMap map[string]*AssociationEdgeGroupStatusInfo

type AssociationEdge ¶

type AssociationEdge struct {
	EntConfig interface{} // zero-value of the struct
	//CustomTableName string      // TODO come back
	// have to pick one or the other
	InverseEdge *InverseAssocEdge
	Symmetric   bool
	// Unique indicates that there's only one instance of this edge
	Unique bool

	// TODO inverse and other fun things about edges
	// same with foreign key edge
	EdgeActions EdgeActions
}

AssociationEdge is the fb-style edge where the information is stored in the edges_info table. This is the preferred edge in the framework

func (AssociationEdge) Name() string

type AssociationEdgeGroup ¶

type AssociationEdgeGroup struct {
	EdgeGroups      AssocEdgeMap
	GroupStatusName string // Name of the group e.g. Rsvp. will be used to create a Node{GroupName}Status object and a bunch of other things
	EdgeActions     EdgeActions
	CustomTableName string

	// Edges limits the edges that are used in the status action calculations. status map.
	// If no edges are provided, all in the group are
	ActionEdges []string
}

func (AssociationEdgeGroup) Name() string

type AssociationEdgeGroupStatusInfo ¶

type AssociationEdgeGroupStatusInfo struct {
	EdgeName          string
	Edge              EdgeType
	ConstName         interface{}
	UseInStatusAction bool
}

type Changeset ¶

type Changeset interface {
	// Returns the Executor which is used to do the write.
	// This should be expected to be called multiple times easily.
	GetExecutor() Executor
	GetViewer() viewer.ViewerContext
	Entity() Entity
	// This should match the PlaceholderID of the MutationBuilder that produced this changeset
	GetPlaceholderID() string
	// keeping these 2 just in case...
	ExistingEnt() Entity //existing ent // hmm we just need ID!
	EntConfig() Config   // just in case...
}

Changeset is what's responsible for actually performing the write Once we get here, we assume that things like privacy and all other things that may prevent a mutation from executing have been dealt with A changeset can be bundled with other changesets to create a mutation dependency tree

type ChangesetWithDependencies ¶

type ChangesetWithDependencies interface {
	Changeset
	// Map of placeholder id -> Builder
	// Useful for the executor to know the correct order of operations when performing writes
	Dependencies() MutationBuilderMap
	// List of dependent changesets
	Changesets() []Changeset
}

ChangesetWithDependencies represents a changeset that has other changesets as dependencies.

type Config ¶

type Config interface {
	// GetTableName returns the underyling database table the model's data is stored
	// TODO how do we get a default value without reflection at run time.
	// TOOD embedding or something fancier later with default values may be better
	GetTableName() string
}

Config interface that configurations for an ent should implement.

type ConfigWithActions ¶

type ConfigWithActions interface {
	Config
	GetActions() []*ActionConfig
}

ConfigWithActions is the interface that EntConfig which have actions implements

type ConfigWithEdges ¶

type ConfigWithEdges interface {
	Config
	// GetEdges returns the edges that the ent supports
	GetEdges() EdgeMap
}

ConfigWithEdges is the interface that EntConfigs which have edges implement

type ConfigWithFields ¶

type ConfigWithFields interface {
	Config
	GetFields() FieldMap
}

ConfigWithFields is the interface that EntConfigs which have fields implement

type DBFields ¶

type DBFields map[string]func(interface{}) error

type DBObject ¶

type DBObject interface {
	// TODO what happens for tables with composite primary keys??
	GetID() string
	DBFields() DBFields
}

DBObject references an item fetched from the database All ents are DBObjects but not all DBOjects are necessarily ents e.g. AssocEdge TODO rename to more generic name that's not DB only.

type DBObjectWithDiffKey ¶

type DBObjectWithDiffKey interface {
	DBObject
	GetPrimaryKey() string // for now only do single primary key
}

DBObjectWithDiffKey should be implemented to indicate that the primary key in the table isn't "id" but a different field. For now only supports single primary key so not exposing it publicly Only used for update at the moment

type DataOperation ¶

type DataOperation interface {
	PerformWrite(tx *sqlx.Tx) error
}

DataOperation corresponds to an individual operation to write to the database could be inserting a node, deleting a node, adding an edge, etc Ent framework comes with different operations which handle common things Each operation is returned by Executor

type DataOperationWithCreatedEnt ¶

type DataOperationWithCreatedEnt interface {
	DataOperation
	CreatedEnt() Entity
}

DataOperationWithCreatedEnt indicates an operation which can create an ent This is used to track placeholder ids and id of the created ent

type DataOperationWithResolver ¶

type DataOperationWithResolver interface {
	DataOperation
	Resolve(Executor) error
}

DataOperationWithResolver corresponds to an operation which can resolve placeholder ids so that the executor ca nbe passed to it as needed

type DeleteNodeOperation ¶

type DeleteNodeOperation struct {
	ExistingEnt Entity
	EntConfig   Config
}

DeleteNodeOperation indicates we're deleting an ent

func (op *DeleteNodeOperation) PerformWrite(tx *sqlx.Tx) error

type DenyWithReasonResult ¶

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

DenyWithReasonResult is the error returned by privacy

func DenyWithReason(err error) DenyWithReasonResult

func (r DenyWithReasonResult) Err() error

func (r DenyWithReasonResult) Error() string

func (r DenyWithReasonResult) Result() privacyResult

type Edge ¶

type Edge interface {
	Name() string
	// contains filtered or unexported methods
}

Edge indicates a relationship/connection between 2 or more nodes This interface isn't fully fleshed out yet but it allows the API to be clearer

type EdgeActionConfig ¶

type EdgeActionConfig struct {
	Action            ActionOperation // only AddEdgeAction and RemoveEdgeAction are supported
	CustomActionName  string          // override default generated Go name
	HideFromGraphQL   bool            // Flag to hide action(s) from GraphQL
	CustomGraphQLName string          // override default graphql name generated
}

EdgeActionConfig provides a way to configure the actions generated for an AssociationEdge

type EdgeActions ¶

type EdgeActions []*EdgeActionConfig

EdgeActions is a named type for a list of EdgeActionConfig for simpler typing

type EdgeMap ¶

type EdgeMap map[string]Edge

EdgeMap is a mapping of name of edge to EdgeType

type EdgeOperation ¶

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

EdgeOperation handles creating, editing or deleting an edge

func NewInboundEdge(
	edgeType EdgeType,
	op WriteOperation,
	id1 interface{},
	nodeType NodeType,
	mb MutationBuilder,
	options ...func(*EdgeOperation)) *EdgeOperation

func NewOutboundEdge(
	edgeType EdgeType,
	op WriteOperation,
	id2 interface{},
	nodeType NodeType,
	mb MutationBuilder,
	options ...func(*EdgeOperation)) *EdgeOperation

func (op *EdgeOperation) EdgeType() EdgeType

func (op *EdgeOperation) InverseEdge(edgeType EdgeType) *EdgeOperation

func (op *EdgeOperation) PerformWrite(tx *sqlx.Tx) error

func (op *EdgeOperation) Resolve(exec Executor) error

func (op *EdgeOperation) SymmetricEdge() *EdgeOperation

type EdgeOptions ¶

type EdgeOptions struct {
	Time time.Time
	Data string
}

EdgeOptions is a struct that can be used to configure an edge. Time refers to the time associated with the edge. If not specified, defaults to current time Data refers to whatever information that needs to be stored/associated with the edge It's up to 255 characters (hmm not true right now)

type EdgeType ¶

type EdgeType string

EdgeType represents the edge between two nodes. Underlying format is uuid Generated automatically by the ent framework.

type EditNodeOperation ¶

type EditNodeOperation struct {
	ExistingEnt         Entity
	Entity              Entity
	EntConfig           Config
	Fields              map[string]interface{}
	FieldsWithResolvers []string
	Operation           WriteOperation
}

EditNodeOperation indicates we're creating or editing an ent

func (op *EditNodeOperation) CreatedEnt() Entity

func (op *EditNodeOperation) PerformWrite(tx *sqlx.Tx) error

func (op *EditNodeOperation) Resolve(exec Executor) error

type Entity ¶

type Entity interface {
	ObjectWithPrivacyPolicy
	// GetType returns the NodeType of this entity
	//	GetID() string // TODO uuid
	GetType() NodeType
	GetViewer() viewer.ViewerContext
	DBObject
}

type Executor ¶

type Executor interface {
	// Provides an io.Read() style API where the underlying dependency details are hidden
	// away. works when it's one changeset with N operations or N changesets with operations across them.
	// When we're done with operations, it returns ErrAllOperations to signal EOF
	Operation() (DataOperation, error)
	// resolve placeholders from this mutation
	// Called by an Operation which has a placeholder id and returns the ent created by a previous operation so that
	// the right value can be written to the database
	ResolveValue(interface{}) Entity
}

Executor is responsible for sequencing complicated writes that have dependencies on each other For simple writes e.g. insert one row in the database, there's just one operation and nothing to do For complicated writes where there's dependencies between objects and the input of one is dependent on the output of the other, the Executor is expected to figure that and ensure that the operations are sequenced correctly so that the action goes off without a hitch The ent framework provides default Executor so only need to know this if default executor isn't suitable.

type FieldMap ¶

type FieldMap map[string]*field.Field

FieldMap is a mapping of name of field to Field

type InvalidEntPrivacyError ¶

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

InvalidEntPrivacyError is the error type returned when an ent does not implement the right privacy policy

func (err *InvalidEntPrivacyError) Error() string

type InvalidPrivacyRule ¶

type InvalidPrivacyRule struct{}

InvalidPrivacyRule is the error type returned when an ent does not have the right privacy rules

func (err *InvalidPrivacyRule) Error() string

type InverseAssocEdge ¶

type InverseAssocEdge struct {
	EdgeName string
}

type LoadEdgeConfig ¶

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

LoadEdgeConfig configures the way to load edges This will eventually be used in EntQuery but allows us to start testing and building some things...

type Loader ¶

type Loader interface {
	// Returns a new instance of the underlying object to be returned to the client for this loader
	// When a privacy backed loader, should return an Entity with ViewerContext of object set
	GetNewInstance() DBObject
	// Returns the schema of the ent.
	GetConfig() Config
}

Loader is used to load one or more ents Loader with no Load method... We need it to work for also efficiently loading multiple ents so one Load() API doesn't work This will also eventually support different loading mechanisms e.g. db, rest API, memory, etc For now, only postgres db is supported

type LoaderWithDiffPrimaryKey ¶

type LoaderWithDiffPrimaryKey interface {
	Loader
	GetPrimaryKey() string // for now only do single primary key
}

type MutationBuilder ¶

type MutationBuilder interface {
	ExistingEnt() Entity
	Entity() Entity           // TODO Ola: maybe this should get loader instance?
	GetPlaceholderID() string // TODO GetMutationID()?
	GetViewer() viewer.ViewerContext
	GetChangeset() (Changeset, error) // TODO rename to Build()
	GetOperation() WriteOperation
}

MutationBuilder is the building block for a mutation or action. Pieces together the different parts needed for a write

type MutationBuilderMap ¶

type MutationBuilderMap map[string]MutationBuilder

MutationBuilderMap is a named type for a map of placeholder ids to the corresponding MutationBuilder

type Node ¶

type Node struct {
	ID string `db:"id"`
	Timestamps
}

Node is a default reusable object that comes with the ent-framework Right now, all ents have to be nodes. Eventually, we'll have a corresponding NodeConfig that is used to add this to the generated ents.

func (node *Node) GetID() string

type NodeType ¶

type NodeType string

NodeType represents each unique node in a project. Generated automatically by the ent framework Eventually will also be used for polymorphic edges, id disambiguation, generic ent loads and other such things

type ObjectWithPrivacyPolicy ¶

type ObjectWithPrivacyPolicy interface {
	GetPrivacyPolicy() PrivacyPolicy
}

type PrivacyBackedLoader ¶

type PrivacyBackedLoader interface {
	Loader
	// Called for each ent returned by GetNewInstance to indicate tbe
	// result of applying the privacy rules to each ent.
	// Loaders should keep track of this and not GetNewInstance() so as
	// to not have privacy violations in returning non-privacy backed code
	// back to clients out of the ent framework
	// @param id string
	// @param ent DBObject (non-nil) if visible to the viewer
	// @param err error error loading given id e.g. user was blocked or just generic privacy error
	SetPrivacyResult(string, DBObject, error)
}

PrivacyBackedLoader is used when we want to apply privacy rules APIs that take this exxpect each instance of the ent returned by GetNewInstance() to be an Entity with the Viewer set to the same viewer passed to the ent API Done this way to have strong typing everywhere with no reflection. Automatically handled by the code generated by the framework so should only be annoying for very custom implementations

type PrivacyError ¶

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

PrivacyError is the error type returned when an ent is not visible due to privacy reasons

func (err *PrivacyError) Error() string

type PrivacyPolicy ¶

type PrivacyPolicy interface {
	Rules() []PrivacyPolicyRule
}

PrivacyPolicy defines the set of Privacy rules that need to be implemented by this ent to end up with a decision on if this ent is visible to the viewer

type PrivacyPolicyRule ¶

type PrivacyPolicyRule interface {
	// Eval is the method called to evaluate the visibility of the ent
	Eval(v viewer.ViewerContext, ent Entity) PrivacyResult
}

PrivacyPolicyRule is an independent PrivacyRule that evaluates an ent and determines if it's visible or not

type PrivacyResult ¶

type PrivacyResult interface {
	Result() privacyResult
}

PrivacyResult is what's returned by privacy methods to indicate what should be returned to the client of ent callers

func Allow() PrivacyResult

func Deny() PrivacyResult

func Skip() PrivacyResult

type Timestamps ¶

type Timestamps struct {
	CreatedAt time.Time `db:"created_at"`
	UpdatedAt time.Time `db:"updated_at"`
}

Timestamps adds 2 time fields to each ent. Right now, it's gotten from ent.Node which is automatically added 2 each ent. Eventually, there'll be a corresponding TimestampsConfig or TimestampsPattern which adds this and there could be ents which aren't Nodes which have these (e.g. AssocEdgeData)

type WriteOperation ¶

type WriteOperation string

WriteOperation indicates if we're creating, editing or deleting an ent

const (
	// InsertOperation means we're creating a new ent
	InsertOperation WriteOperation = "insert"
	// EditOperation means we're editing an existing ent
	EditOperation WriteOperation = "edit"
	// DeleteOperation means we're deleting an ent
	DeleteOperation WriteOperation = "delete"
)