model

type Column struct {
	// QueryName is the name of the column in the database.
	QueryName string
	// Table is a pointer back to the table that this column is part of
	Table *Table
	// Identifier is the name of the accessor function in go code. e.g. "FirstName".
	Identifier string
	// Field is the name of the field in the Table struct that will hold the column's value.
	// It is also used as the name for a function parameter.
	Field string
	// FieldPlural is the plural form of Field.
	FieldPlural string
	// Label is the name that identifies the value to humans. e.g. "First Name".
	Label string
	// Type is the Go type that the column represents to the rest of the Go application.
	Type string
	// SchemaType is the type info specified in the schema description
	SchemaType schema2.ColumnType
	// SchemaSubType further describes the schema type.
	SchemaSubType schema2.ColumnSubType
	//  ReceiverType is the Go type that will be received from the database.
	ReceiverType ReceiverType
	// Size is the maximum length of runes to allow in the column if a string type column.
	// If a byte array, it is the number of bytes permitted.
	// If an attempt at entering more than this amount occurs, it is considered a programming bug
	// and we will panic.
	// If an integer or float type, it is the number of bits in the data type.
	Size uint64
	// DefaultValue is the default value as specified by the database. We will initialize new ORM objects
	// with this value.
	DefaultValue interface{}
	// IsNullable is true if the column can be given a NULL value.
	IsNullable bool
	// If this is an enum type, Enum will point to the Enum object.
	Enum *Enum
	// If this column is a reference, a pointer to the Reference object.
	Reference *Reference
	// Options are the options extracted from the comments string
	Options map[string]interface{}
}

type ConstValue struct {
	// Value is the integer that will represent the value
	Value int
	// Name is the CamelCase name that represents the value (without the table name prefix)
	Name string
	// Key is the snake_case key that will represent the value.
	Key string
	// FieldValues are the additional values associated with the field. At a minimum, it will have a "label" entry.
	// This should correspond to the entries in Enum.Fields.
	FieldValues map[string]any
}

type Database struct {
	// The database key corresponding to its key in the global database cluster
	Key string
	// ImportPath is the module path to the output directory.
	ImportPath string
	// WriteTimeout is used to wrap write transactions with a timeout on their contexts.
	// Leaving it as zero will turn off timeout wrapping, allowing you to wrap individual calls as you
	// see fit.
	WriteTimeout time.Duration
	// ReadTimeout is used to wrap read transactions with a timeout on their contexts.
	// Leaving it as zero will turn off timeout wrapping, allowing you to wrap individual calls as you
	// see fit.
	ReadTimeout time.Duration
	// Tables are the tables in the database, keyed by database table name
	Tables map[string]*Table
	// Enums contains a description of the enumerated types linked to the database, keyed by database table name
	Enums map[string]*Enum

	// EnumTableSuffix is the text to string off the end of an enum table when converting it to a type name.
	// Defaults to "_enum".
	EnumTableSuffix string
	// Defaults to _assn
	AssnTableSuffix string
}

type Enum struct {
	// DbKey is the key used to find the database in the global database cluster.
	DbKey string
	// QueryName is the name of the table to use in querying the database.
	QueryName string
	// Label is the english name of the object when describing it to the world.
	Label string
	// LabelPlural is the plural english name of the object.
	LabelPlural string
	// Identifier is the name of the item as a go type name.
	Identifier string
	// IdentifierPlural is the plural of the go type name.
	IdentifierPlural string
	// DecapIdentifier is the Identifier with the first letter lower case.
	DecapIdentifier string
	// Fields are the names of accessor functions associated with the type.
	// The first field name MUST be "label". There may be additional fields.
	Fields []EnumField
	// Constants are the constant identifiers that will be used for each enumerated value.
	// These are in ascending order by keys.
	Constants []ConstValue
}

type EnumField struct {
	// QueryName is the name of the field in the database.
	// QueryNames should be lower_snake_case.
	QueryName string
	// Identifier is the name used in Go code to access the data.
	Identifier string
	// IdentifierPlural is the plural form of Identifier.
	IdentifierPlural string
	// Type is the ReceiverType of the column.
	Type ReceiverType
}

type Index struct {
	// IsUnique indicates whether the index is unique
	IsUnique bool
	// Columns are the columns that are part of the index
	Columns    []*Column
	Name       string
	Identifier string
}

type ManyManyReference struct {
	// TableQueryName is the database table that links the two associated tables together.
	TableQueryName string
	// ForeignKeyName is the database column in the association table that points at the referenced table's primary key.
	ForeignKeyName string
	// ForeignKeyReceiverType is the query.ReceiverType of the destination column.
	ForeignKeyReceiverType query.ReceiverType
	// ReferencedTable is the table being linked.
	ReferencedTable *Table

	// Label is the human-readable label of the objects pointed to.
	Label string
	// LabelPlural is the plural of Label
	LabelPlural string
	// Identifier is the name used to refer to an object on the other end of the reference.
	// It is not the same as the object type. For example TeamMember would refer to a Person type.
	// This is derived from the ForeignKeyName but can be overridden.
	Identifier string
	// IdentifierPlural is the name used to refer to the group of objects on the other end of the reference.
	// For example, TeamMembers. This is derived from the ForeignKeyName but can be overridden by
	// a comment in the table.
	IdentifierPlural string
	// Field is the go identifier that will be used in the Table struct and parameters.
	// Since this always points to many objects, it will be a plural name.
	Field string

	// MM is the many-many reference on the other end of the relationship that points back to this one.
	MM *ManyManyReference
}

type Reference struct {
	// Table is a pointer back to the table this reference is part of.
	Table *Table
	// ReferencedTable is the table being pointed to by ForeignKey.
	ReferencedTable *Table
	// ForeignKey is the local column that is referring to the referenced table
	ForeignKey *Column
	// Identifier is the go identifier used as an accessor to the forward referenced object.
	// Example: ProjectManager
	Identifier string
	// Field is the name used in the struct representing a pointer to the referenced object.
	// Also used as a function parameter name and the query identifier.
	// Example: projectManager
	Field string
	// The human-readable label of the object referred to.
	// Example: Project Manager
	Label string
	// ReverseIdentifier is the name ReferencedTable should use to refer to the singular related object.
	ReverseIdentifier string
	// ReverseIdentifierPlural is the name ReferencedTable should use to refer to the plural related objects
	// if this is not a unique reference.
	// Example: Projects
	ReverseIdentifierPlural string
	// ReverseLabel is the human-readable label of the object of the reverse relationship.
	// Example: Project
	ReverseLabel string
	// ReverseLabelPlural is the plural of ReverseLabel.
	// Example: Projects
	ReverseLabelPlural string
	// ReverseField is the name used in the struct for the reverse object(s)
	ReverseField string
	// IsUnique is true if this is a one-to-one relationship
	IsUnique bool
	// IsNullable is true if the foreign keys are nullable. This also indicates that the
	// reference is not required when the table is saved.
	IsNullable bool
}

type Table struct {
	// DbKey is the key used to find the database in the global database cluster
	DbKey string
	// WriteTimeout is used to wrap write transactions with a timeout on their contexts.
	// Leaving it as zero will use the timeout in the database, if one is set.
	WriteTimeout time.Duration
	// ReadTimeout is used to protect read transactions with a timeout on their contexts.
	// Leaving it as zero will use the timeout in the database, if one is set.
	ReadTimeout time.Duration
	// NoTest indicates that the table should NOT have an automated test generated for it.
	NoTest bool
	// QueryName is the database's identifier for the table.
	QueryName string
	// Label is the name of the object when describing it to the world. Should be lower case.
	Label string
	// LabelPlural is the plural name of the object.
	LabelPlural string
	// Identifier is the name of the struct type when referring to it in go code.
	Identifier string
	// IdentifierPlural is the name of a collection of these objects when referring to them in go code.
	IdentifierPlural string
	// DecapIdentifier is the same as Identifier, but the first letter is lower case.
	DecapIdentifier string
	// Columns is a list of Columns, one for each column in the table, but does not include columns in references.
	Columns []*Column
	// Indexes are all the indexes defined on the table, single and multi-column, but not primary key.
	Indexes []Index
	// Options are key-value pairs of values that can be used to customize how code generation is performed
	Options map[string]interface{}
	// References are all the foreign keys. References contains additional columns.
	References []*Reference
	// ReverseReferences are the columns from other tables, or even this table,
	// that point to this table.
	ReverseReferences []*Reference
	// ManyManyReferences describe the many-to-many references pointing to this table
	ManyManyReferences []*ManyManyReference
	// The cached optimistic locking column, if one is present
	LockColumn *Column
	// contains filtered or unexported fields
}